turbo-editors/turbo-golo · ce0b014

added .memory/handoffs/2026-09-21-asciidoc-docs.md +5 -0 Viewed

new file mode 100644
@@ -0,0 +1,5 @@
	1	+# Handoff — 2026-09-21 — AsciiDoc in turbo-core v1.0.4: this editor's side
	2	+
	3	+- Template comment and docs (EN+FR) already say nine languages and describe AsciiDoc; nothing else here changes.
	4	+- Next: when turbo-core v1.0.4 is tagged, `go get rickub.com/turbo-editors/turbo-core@v1.0.4 && go mod tidy && GOWORK=off make check`. Then open a `.adoc` file in the real editor once and check it colours.
	5	+- Trap: `templates_test.go` iterates `syntax.Registered()`; any further built-in language in turbo-core needs one more word in the template comment here, before the pin.

++# Handoff — 2026-09-21 — AsciiDoc in turbo-core v1.0.4: this editor's side
++
++- Template comment and docs (EN+FR) already say nine languages and describe AsciiDoc; nothing else here changes.
++- **Next**: when turbo-core v1.0.4 is tagged, `go get rickub.com/turbo-editors/turbo-core@v1.0.4 && go mod tidy && GOWORK=off make check`. Then open a `.adoc` file in the real editor once and check it colours.
++- **Trap**: `templates_test.go` iterates `syntax.Registered()`; any further built-in language in turbo-core needs one more word in the template comment here, before the pin.

added .memory/handoffs/2026-09-21-terminal-clipboard-docs.md +5 -0 Viewed

new file mode 100644
@@ -0,0 +1,5 @@
	1	+# Handoff — 2026-09-21 — terminal copy/paste in turbo-core v1.0.4: this editor's side
	2	+
	3	+- Docs (EN+FR) already describe `Ctrl-Ins` / `Shift-Ins` / `Shift-↑↓` / mouse drag in a terminal window and bracketed paste (mode 2004); no code here changes.
	4	+- Next: when turbo-core v1.0.4 is tagged, `go get rickub.com/turbo-editors/turbo-core@v1.0.4 && go mod tidy && GOWORK=off make check`. Then try one round trip by hand: drag over shell output, `Ctrl-Ins`, `Shift-Ins` into a file, and back.
	5	+- Trap: until the re-pin, a binary built with `GOWORK=off` shows docs for a feature it does not have — build under the umbrella `go.work` to see it.

++# Handoff — 2026-09-21 — terminal copy/paste in turbo-core v1.0.4: this editor's side
++
++- Docs (EN+FR) already describe `Ctrl-Ins` / `Shift-Ins` / `Shift-↑↓` / mouse drag in a terminal window and bracketed paste (mode 2004); no code here changes.
++- **Next**: when turbo-core v1.0.4 is tagged, `go get rickub.com/turbo-editors/turbo-core@v1.0.4 && go mod tidy && GOWORK=off make check`. Then try one round trip by hand: drag over shell output, `Ctrl-Ins`, `Shift-Ins` into a file, and back.
++- **Trap**: until the re-pin, a binary built with `GOWORK=off` shows docs for a feature it does not have — build under the umbrella `go.work` to see it.

modified .memory/history.md +10 -0 Viewed

@@ -92,3 +92,13 @@ One dated entry per session, appended at the end. Never rewritten.
92	92	- Later, same session: `release.env` is now committed — `.gitignore` gained `!release.env` under `.env`, with a comment; `.token.env` files stay ignored (verified with `git check-ignore` in every repository). The comments that said it was ignored were reworded to match: `02-build-releases.sh`, `.github/workflows/release.yml`, the release how-to (EN+FR), and this summary. Asked by the user so the version and its description travel with the repository.
93	93	- End of session: turbo-core v1.0.3 having been published and `go.mod` re-pinned to it from the host, `GOWORK=off go test ./... -count=1` is entirely green here, the two release-script tests included.
94	94
	95	+## 2026-09-21 — AsciiDoc arrives in turbo-core (ticket #31): template comment and docs ahead of the re-pin
	96	+
	97	+- Changed here: the `languages` comment of `snippets.toml.tmpl` names `asciidoc`; `docs/{en,fr}/reference/languages.md` gained an `AsciiDoc` recognition row, `AsciiDoc` in the class rows it uses, and an `## AsciiDoc` section after Markdown's; every sentence counting turbo-core's eight languages says nine and lists AsciiDoc. Done from the umbrella session that added the scanner to turbo-core (for v1.0.4).
	98	+- Why now: `templates_test.go` checks the created snippets file names every `syntax.Registered()` language, so the comment would have gone red the moment `go.mod` moved to v1.0.4. Against the pinned v1.0.3 the test still passes (presence, not exactness).
	99	+- Not done: `go.mod` still pins v1.0.3; nothing committed.
	100	+
	101	+## 2026-09-21 — terminal copy/paste arrives in turbo-core v1.0.4: docs ahead of the re-pin
	102	+
	103	+- Changed here (docs only, EN+FR): `how-to/use-a-terminal.md` gained "Copy from the terminal into a file, and back"; `reference/terminal.md` gained the selection keys, the drag row, a "Copying and pasting" table, private mode 2004, `editor.selection` in the colours, and lost "bracketed paste" from the not-implemented list; `reference/keyboard.md` gained the terminal and mouse rows; `explanation/terminal-windows.md` gained "Copying out and pasting in". Applied from the umbrella session that added the feature to turbo-core, by one anchored script across the six editors.
	104	+- Not done: `go.mod` still pins v1.0.3, so the binary built without the workspace does not yet have the feature the docs describe; nothing committed.

  - **Later, same session**: `release.env` is now **committed** — `.gitignore` gained `!release.env` under `*.env`, with a comment; `*.token.env` files stay ignored (verified with `git check-ignore` in every repository). The comments that said it was ignored were reworded to match: `02-build-releases.sh`, `.github/workflows/release.yml`, the release how-to (EN+FR), and this summary. Asked by the user so the version and its description travel with the repository.
  - **End of session**: turbo-core v1.0.3 having been published and `go.mod` re-pinned to it from the host, `GOWORK=off go test ./... -count=1` is entirely green here, the two release-script tests included.
++## 2026-09-21 — AsciiDoc arrives in turbo-core (ticket #31): template comment and docs ahead of the re-pin
++
++- **Changed here**: the `languages` comment of `snippets.toml.tmpl` names `asciidoc`; `docs/{en,fr}/reference/languages.md` gained an `AsciiDoc` recognition row, `AsciiDoc` in the class rows it uses, and an `## AsciiDoc` section after Markdown's; every sentence counting turbo-core's eight languages says nine and lists AsciiDoc. Done from the umbrella session that added the scanner to turbo-core (for v1.0.4).
++- **Why now**: `templates_test.go` checks the created snippets file names every `syntax.Registered()` language, so the comment would have gone red the moment `go.mod` moved to v1.0.4. Against the pinned v1.0.3 the test still passes (presence, not exactness).
++- **Not done**: `go.mod` still pins v1.0.3; nothing committed.
++
++## 2026-09-21 — terminal copy/paste arrives in turbo-core v1.0.4: docs ahead of the re-pin
++
++- **Changed here** (docs only, EN+FR): `how-to/use-a-terminal.md` gained "Copy from the terminal into a file, and back"; `reference/terminal.md` gained the selection keys, the drag row, a "Copying and pasting" table, private mode 2004, `editor.selection` in the colours, and lost "bracketed paste" from the not-implemented list; `reference/keyboard.md` gained the terminal and mouse rows; `explanation/terminal-windows.md` gained "Copying out and pasting in". Applied from the umbrella session that added the feature to turbo-core, by one anchored script across the six editors.
++- **Not done**: `go.mod` still pins v1.0.3, so the binary built without the workspace does not yet have the feature the docs describe; nothing committed.

modified .memory/summary.md +4 -0 Viewed

@@ -109,3 +109,7 @@ go list -f '{{.Dir}}' rickub.com/turbo-editors/turbo-core/app # must NOT be un
109	109
110	110	- `-load-config <url>` is wired (`main.go`: `loadConfig`, `describeLoad`), on top of turbo-core's `configrepo`. `go.mod` pins turbo-core v1.0.3, which is published (re-pinned from the host on 2026-09-20), so it builds on its own again. A project with a `.turbo-golo` already is refused, not overwritten.
111	111
	112	+## State as of 2026-09-21
	113	+
	114	+- Docs and the snippets template already describe turbo-core v1.0.4's AsciiDoc (ninth built-in language) while `go.mod` still pins v1.0.3; the suite passes either way. Re-pin when v1.0.4 is tagged.
	115	+

  - **`-load-config <url>` is wired** (`main.go`: `loadConfig`, `describeLoad`), on top of turbo-core's `configrepo`. `go.mod` pins **turbo-core v1.0.3**, which is published (re-pinned from the host on 2026-09-20), so it builds on its own again. A project with a `.turbo-golo` already is refused, not overwritten.
++## State as of 2026-09-21
++
++- Docs and the snippets template already describe **turbo-core v1.0.4's AsciiDoc** (ninth built-in language) while `go.mod` still pins v1.0.3; the suite passes either way. Re-pin when v1.0.4 is tagged.
++

modified docs/en/explanation/architecture.md +1 -1 Viewed

@@ -56,7 +56,7 @@ Everything that would otherwise be a hardcoded `"turbo-golo"`, `"golo"` or `".go
56	56
57	57	## Why the scanner is here and not in the library
58	58
59		-turbo-core colours eight languages itself: TOML, YAML, Markdown, JavaScript, HTML, XML, Dockerfiles and shell. Those are the ones every editor meets whatever it is for — a project's configuration is TOML or YAML, its documentation is Markdown, its scripts are shell, its image build a Dockerfile.
	59	+turbo-core colours nine languages itself: TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, Dockerfiles and shell. Those are the ones every editor meets whatever it is for — a project's configuration is TOML or YAML, its documentation is Markdown, its scripts are shell, its image build a Dockerfile.
60	60
61	61	Golo is not one of them, and neither are Go, Rust, Python or MoonBit. The language that defines an editor is registered by that editor, which is why a `.mbt` file opens as plain text here and a `.golo` file opens as plain text in Turbo MoonBit.
62	62

  ## Why the scanner is here and not in the library
--turbo-core colours eight languages itself: TOML, YAML, Markdown, JavaScript, HTML, XML, Dockerfiles and shell. Those are the ones every editor meets whatever it is for — a project's configuration is TOML or YAML, its documentation is Markdown, its scripts are shell, its image build a Dockerfile.
++turbo-core colours nine languages itself: TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, Dockerfiles and shell. Those are the ones every editor meets whatever it is for — a project's configuration is TOML or YAML, its documentation is Markdown, its scripts are shell, its image build a Dockerfile.
  Golo is not one of them, and neither are Go, Rust, Python or MoonBit. The language that *defines* an editor is registered by that editor, which is why a `.mbt` file opens as plain text here and a `.golo` file opens as plain text in Turbo MoonBit.

modified docs/en/explanation/colouring-and-completion.md +3 -3 Viewed

@@ -20,7 +20,7 @@ It cannot be imported. GoloScript's `go.mod` says `module golo`: a bare name, no
20	20
21	21	So the lexer is the specification rather than a dependency. `lexer/lexer.go` and `token/token.go` say what a token is — which runes open a comment, how a number ends, which words are reserved — and this scanner says the same thing in the library's `LineScanner` style. Where the two could disagree, the lexer's line is quoted in the code beside the decision.
22	22
23		-The scanner it is. Some six hundred lines, one file each for the dispatcher, the literals and the words — and no attempt at a general engine. There is no pattern language, no grammar format and no table of regular expressions: it is ordinary Go that a reader can follow, which is the same rule the eight scanners in turbo-core follow.
	23	+The scanner it is. Some six hundred lines, one file each for the dispatcher, the literals and the words — and no attempt at a general engine. There is no pattern language, no grammar format and no table of regular expressions: it is ordinary Go that a reader can follow, which is the same rule the nine scanners in turbo-core follow.
24	24
25	25	## What crosses a line break, and why it is carried rather than cut
26	26
@@ -75,9 +75,9 @@ Where a construct cannot be recognised from what one line holds, it is left alon
75	75	\| Escapes inside `"""…"""` \| The lexer appends every rune until the three quotes, so `"""a\"""` ends at the first `"""` whatever the backslash meant \|
76	76	\| Whether a name is bound in this scope \| Nothing here reads more than one line at a time; that is the language server's question, and [F1 answers it](../how-to/ask-about-code.md) \|
77	77
78		-## The other eight languages come free
	78	+## The other nine languages come free
79	79
80		-TOML, YAML, Markdown, JavaScript, HTML, XML, Dockerfiles and shell are coloured by turbo-core, not here. A Golo project has a `README.md`, a `compose.yaml` for the service it talks to, a Dockerfile to ship as, and an editor that coloured only the `.golo` files would make you leave it for the rest.
	80	+TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, Dockerfiles and shell are coloured by turbo-core, not here. A Golo project has a `README.md`, a `compose.yaml` for the service it talks to, a Dockerfile to ship as, and an editor that coloured only the `.golo` files would make you leave it for the rest.
81	81
82	82	That they are shared rather than copied is the point of the library: they were written once, for Turbo Go, and Turbo Golo got them by importing a package.
83	83

  So the lexer is the **specification** rather than a dependency. `lexer/lexer.go` and `token/token.go` say what a token is — which runes open a comment, how a number ends, which words are reserved — and this scanner says the same thing in the library's `LineScanner` style. Where the two could disagree, the lexer's line is quoted in the code beside the decision.
--The scanner it is. Some six hundred lines, one file each for the dispatcher, the literals and the words — and no attempt at a general engine. There is no pattern language, no grammar format and no table of regular expressions: it is ordinary Go that a reader can follow, which is the same rule the eight scanners in turbo-core follow.
++The scanner it is. Some six hundred lines, one file each for the dispatcher, the literals and the words — and no attempt at a general engine. There is no pattern language, no grammar format and no table of regular expressions: it is ordinary Go that a reader can follow, which is the same rule the nine scanners in turbo-core follow.
  ## What crosses a line break, and why it is carried rather than cut
  | Escapes inside `"""…"""` | The lexer appends every rune until the three quotes, so `"""a\"""` ends at the first `"""` whatever the backslash meant |
  | Whether a name is bound in this scope | Nothing here reads more than one line at a time; that is the language server's question, and [F1 answers it](../how-to/ask-about-code.md) |
--## The other eight languages come free
++## The other nine languages come free
--TOML, YAML, Markdown, JavaScript, HTML, XML, Dockerfiles and shell are coloured by turbo-core, not here. A Golo project has a `README.md`, a `compose.yaml` for the service it talks to, a Dockerfile to ship as, and an editor that coloured only the `.golo` files would make you leave it for the rest.
++TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, Dockerfiles and shell are coloured by turbo-core, not here. A Golo project has a `README.md`, a `compose.yaml` for the service it talks to, a Dockerfile to ship as, and an editor that coloured only the `.golo` files would make you leave it for the rest.
  That they are shared rather than copied is the point of the library: they were written once, for Turbo Go, and Turbo Golo got them by importing a package.

modified docs/en/explanation/terminal-windows.md +8 -0 Viewed

@@ -38,6 +38,14 @@ Those exceptions are not a compromise between the two claims — they are the wa
38	38
39	39	What this costs is real and worth naming: `Alt-B` and `Alt-F` reach the shell, so readline's word movement works, but a program inside a terminal window can never see `F1`…`F12`. `htop`'s function-key menu is unreachable. That is the trade, and it was made in favour of always being able to get out.
40	40
	41	+## Copying out and pasting in
	42	+
	43	+A terminal's output is wanted elsewhere as often as it is read: a path out of a build error, a line of a stack trace, a command's result to paste into the file beside it. And the other way round, a command written in a file and wanted at the prompt. The two obvious keys are unavailable, and the previous section says why: `Ctrl-C` interrupts and `Ctrl-V` is readline's quoted-insert, and a terminal that took either would be a worse terminal. So the terminal has the editor's other spelling of the same two commands, `Ctrl-Ins` and `Shift-Ins`, which the Edit menu already shows and which no shell has a use for — sent through, either would arrive as a plain `Insert` and toggle overwrite mode.
	44	+
	45	+The selection is stored as two cells of the whole text, history and live screen together, rather than as screen positions. That is what lets a selection survive the shell writing below it: a line that scrolls off the top into the history keeps its index, because the history grows by exactly the row the screen lost. Keyboard selection is by whole lines, as in the agent window and for the same reason — nothing here is edited, and a whole line is nearly always what was meant; the mouse selects by character because a path in the middle of a line is the other thing people want. Copying goes to both clipboards, the editor's and the system's, again as in the agent window and for the same reason: "copy this" from a terminal usually means to take it out of the editor entirely.
	46	+
	47	+Pasting is the one place the emulator's boundary moved. A paste is typed into the shell with `Enter` for each line ending, which is what a terminal does; but `bash`, `zsh` and `fish` all ask for bracketed paste — private mode 2004 — precisely so that a multi-line paste arrives as one block to edit rather than as lines to run. The emulator used to ignore that mode with the others. It now remembers it, and only that: it still never pastes on its own, but when the editor pastes on the user's behalf it can wrap the text in the marks the shell asked for. A paste from outside the editor into a terminal window is handed over the same way, whole, rather than replayed as keystrokes — the same rule the agent window's box follows.
	48	+
41	49	## Why closing a terminal asks nothing
42	50
43	51	Closing a modified file asks whether to save it. Closing a terminal does not ask anything at all, and that asymmetry is deliberate.

  What this costs is real and worth naming: `Alt-B` and `Alt-F` reach the shell, so readline's word movement works, but a program inside a terminal window can never see `F1`…`F12`. `htop`'s function-key menu is unreachable. That is the trade, and it was made in favour of always being able to get out.
++## Copying out and pasting in
++
++A terminal's output is wanted elsewhere as often as it is read: a path out of a build error, a line of a stack trace, a command's result to paste into the file beside it. And the other way round, a command written in a file and wanted at the prompt. The two obvious keys are unavailable, and the previous section says why: `Ctrl-C` interrupts and `Ctrl-V` is readline's quoted-insert, and a terminal that took either would be a worse terminal. So the terminal has the editor's *other* spelling of the same two commands, `Ctrl-Ins` and `Shift-Ins`, which the Edit menu already shows and which no shell has a use for — sent through, either would arrive as a plain `Insert` and toggle overwrite mode.
++
++The selection is stored as two cells of the whole text, history and live screen together, rather than as screen positions. That is what lets a selection survive the shell writing below it: a line that scrolls off the top into the history keeps its index, because the history grows by exactly the row the screen lost. Keyboard selection is by whole lines, as in the agent window and for the same reason — nothing here is edited, and a whole line is nearly always what was meant; the mouse selects by character because a path in the middle of a line is the other thing people want. Copying goes to both clipboards, the editor's and the system's, again as in the agent window and for the same reason: "copy this" from a terminal usually means to take it out of the editor entirely.
++
++Pasting is the one place the emulator's boundary moved. A paste is typed into the shell with `Enter` for each line ending, which is what a terminal does; but `bash`, `zsh` and `fish` all ask for *bracketed paste* — private mode 2004 — precisely so that a multi-line paste arrives as one block to edit rather than as lines to run. The emulator used to ignore that mode with the others. It now remembers it, and only that: it still never pastes on its own, but when the editor pastes on the user's behalf it can wrap the text in the marks the shell asked for. A paste from outside the editor into a terminal window is handed over the same way, whole, rather than replayed as keystrokes — the same rule the agent window's box follows.
++
  ## Why closing a terminal asks nothing
  Closing a modified file asks whether to save it. Closing a terminal does not ask anything at all, and that asymmetry is deliberate.

modified docs/en/how-to/navigate-code.md +1 -1 Viewed

@@ -62,7 +62,7 @@ If the windows are on top of each other, `Window ▸ Tile` lays them out side by
62	62
63	63	## Variants
64	64
65		-The file is not Golo. Everything above works except F12, which needs a language server, and the only one this editor starts is `golo lsp`, for Golo. Colouring is unaffected: the eight other languages the editor knows — TOML, YAML, Markdown, JavaScript, HTML, XML, Dockerfiles and shell — are coloured as usual; see [Languages coloured](../reference/languages.md).
	65	+The file is not Golo. Everything above works except F12, which needs a language server, and the only one this editor starts is `golo lsp`, for Golo. Colouring is unaffected: the nine other languages the editor knows — TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, Dockerfiles and shell — are coloured as usual; see [Languages coloured](../reference/languages.md).
66	66
67	67	You want to see where you are. The right-hand end of the status bar always shows `line:column`, counting from one.
68	68

  ## Variants
--**The file is not Golo.** Everything above works except F12, which needs a language server, and the only one this editor starts is `golo lsp`, for Golo. Colouring is unaffected: the eight other languages the editor knows — TOML, YAML, Markdown, JavaScript, HTML, XML, Dockerfiles and shell — are coloured as usual; see [Languages coloured](../reference/languages.md).
++**The file is not Golo.** Everything above works except F12, which needs a language server, and the only one this editor starts is `golo lsp`, for Golo. Colouring is unaffected: the nine other languages the editor knows — TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, Dockerfiles and shell — are coloured as usual; see [Languages coloured](../reference/languages.md).
  **You want to see where you are.** The right-hand end of the status bar always shows `line:column`, counting from one.

modified docs/en/how-to/use-a-terminal.md +15 -0 Viewed

@@ -37,6 +37,21 @@ What the editor keeps is short, and deliberate — it is the way back out:
37	37
38	38	Typing anything brings you straight back to the live screen, so you never have to scroll back down before running the next command.
39	39
	40	+## Copy from the terminal into a file, and back
	41	+
	42	+The shell keeps `Ctrl-C` and `Ctrl-V`, so the terminal uses the editor's other spelling of copy and paste — the one the Edit menu shows.
	43	+
	44	+Out of the terminal. Select what you want, then press `Ctrl-Ins` (or choose Edit ▸ Copy):
	45	+
	46	+- With the mouse, drag over the text. A drag that runs past the window's edge keeps selecting up to it.
	47	+- With the keyboard, `Shift-↑` and `Shift-↓` select whole lines, starting from the line the shell's cursor is on and growing a line at a time.
	48	+
	49	+The selection is highlighted, and the status bar says how many lines were copied. The text goes on the editor's clipboard and, if your terminal allows it, on the system's too. Switch to a file and press `Shift-Ins` to paste it. A window whose command has finished can still be selected and copied from.
	50	+
	51	+Into the terminal. Copy something in a file — `Ctrl-Ins`, or `Ctrl-C` there — bring the terminal forward and press `Shift-Ins` (or Edit ▸ Paste). The text is typed into the shell with an Enter for each line ending, so a multi-line paste runs line by line — unless the shell asked for bracketed paste, as `bash`, `zsh` and `fish` do, in which case it gets the whole block to edit before running. A paste from outside the editor into a terminal window is handed over the same way.
	52	+
	53	+A plain click drops a selection. Ctrl-Ins with nothing selected does nothing, and never reaches the shell.
	54	+
40	55	## Work with the file and the shell side by side
41	56
42	57	A terminal is an ordinary window, so the window commands all apply to it:

  Typing anything brings you straight back to the live screen, so you never have to scroll back down before running the next command.
++## Copy from the terminal into a file, and back
++
++The shell keeps `Ctrl-C` and `Ctrl-V`, so the terminal uses the editor's other spelling of copy and paste — the one the Edit menu shows.
++
++**Out of the terminal.** Select what you want, then press `Ctrl-Ins` (or choose **Edit ▸ Copy**):
++
++- **With the mouse**, drag over the text. A drag that runs past the window's edge keeps selecting up to it.
++- **With the keyboard**, `Shift-↑` and `Shift-↓` select whole lines, starting from the line the shell's cursor is on and growing a line at a time.
++
++The selection is highlighted, and the status bar says how many lines were copied. The text goes on the editor's clipboard and, if your terminal allows it, on the system's too. Switch to a file and press `Shift-Ins` to paste it. A window whose command has finished can still be selected and copied from.
++
++**Into the terminal.** Copy something in a file — `Ctrl-Ins`, or `Ctrl-C` there — bring the terminal forward and press `Shift-Ins` (or **Edit ▸ Paste**). The text is typed into the shell with an Enter for each line ending, so a multi-line paste runs line by line — unless the shell asked for bracketed paste, as `bash`, `zsh` and `fish` do, in which case it gets the whole block to edit before running. A paste from outside the editor into a terminal window is handed over the same way.
++
++A plain click drops a selection. Ctrl-Ins with nothing selected does nothing, and never reaches the shell.
++
  ## Work with the file and the shell side by side
  A terminal is an ordinary window, so the window commands all apply to it:

modified docs/en/reference/keyboard.md +4 -0 Viewed

@@ -152,6 +152,9 @@ A terminal window in front gets every key except the function keys, `Alt-X`
152	152	\| Key \| Action \|
153	153	\| --- \| --- \|
154	154	\| `Shift-PgUp` `Shift-PgDn` \| Read back / forward one screenful through the history \|
	155	+\| `Shift-↑` `Shift-↓` \| Select whole lines, from the shell's cursor line \|
	156	+\| `Ctrl-Ins` \| Copy the selection (also Edit ▸ Copy) \|
	157	+\| `Shift-Ins` \| Paste the editor's clipboard into the shell (also Edit ▸ Paste) \|
155	158	\| anything else not reserved above \| Sent to the shell, returning the view to the live screen \|
156	159
157	160	The exact byte each key sends is in [Terminal windows](terminal.md).
@@ -184,4 +187,5 @@ Handled when the tree window has the focus. The full rules are in [Project tree]
184	187	\| Click `[■]` \| Fill the desktop with the window \|
185	188	\| Click `[▬]` \| Put a filled window back where it was \|
186	189	\| Wheel over a terminal \| Scroll three lines through its history \|
	190	+\| Drag over a terminal \| Select text; a click drops the selection \|
187	191	\| Click a tree row \| Highlight it; a second click opens it \|

  | Key | Action |
  | --- | --- |
  | `Shift-PgUp` `Shift-PgDn` | Read back / forward one screenful through the history |
++| `Shift-↑` `Shift-↓` | Select whole lines, from the shell's cursor line |
++| `Ctrl-Ins` | Copy the selection (also **Edit ▸ Copy**) |
++| `Shift-Ins` | Paste the editor's clipboard into the shell (also **Edit ▸ Paste**) |
  | anything else not reserved above | Sent to the shell, returning the view to the live screen |
  The exact byte each key sends is in [Terminal windows](terminal.md).
  | Click `[■]` | Fill the desktop with the window |
  | Click `[▬]` | Put a filled window back where it was |
  | Wheel over a terminal | Scroll three lines through its history |
++| Drag over a terminal | Select text; a click drops the selection |
  | Click a tree row | Highlight it; a second click opens it |

modified docs/en/reference/languages.md +32 -9 Viewed

@@ -12,6 +12,7 @@ A file's extension decides whenever it is one of these:
12	12	\| `.toml` \| TOML \|
13	13	\| `.yaml`, `.yml` \| YAML \|
14	14	\| `.md`, `.markdown` \| Markdown \|
	15	+\| `.adoc`, `.asciidoc` \| AsciiDoc \|
15	16	\| `.js`, `.mjs`, `.cjs` \| JavaScript \|
16	17	\| `.html`, `.htm` \| HTML \|
17	18	\| `.xml`, `.xsd`, `.xsl`, `.xslt`, `.svg`, `.plist`, `.csproj`, `.pom` \| XML \|
@@ -51,22 +52,22 @@ Every scanner produces the same vocabulary of classes, and each maps to one them
51	52	\| Class \| Theme key \| Produced by \|
52	53	\| --- \| --- \| --- \|
53	54	\| `identifier` \| `syntax.identifier` \| Golo, TOML, JavaScript, shell, YAML, Dockerfile \|
54		-\| `keyword` \| `syntax.keyword` \| Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile \|
	55	+\| `keyword` \| `syntax.keyword` \| Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile, AsciiDoc \|
55	56	\| `type` \| `syntax.type` \| Golo (capitalised names and module paths), TOML (table headers), YAML (tags) \|
56	57	\| `builtin` \| `syntax.builtin` \| Golo (the interpreter's functions), JavaScript, shell (builtins and expansions), YAML (anchors and aliases), Dockerfile (variables) \|
57		-\| `constant` \| `syntax.constant` \| Golo, TOML, JavaScript, shell, YAML, HTML and XML (entities) \|
	58	+\| `constant` \| `syntax.constant` \| Golo, TOML, JavaScript, shell, YAML, HTML and XML (entities), AsciiDoc \|
58	59	\| `function` \| `syntax.function` \| Golo, JavaScript, shell (the command) \|
59		-\| `string` \| `syntax.string` \| all \|
	60	+\| `string` \| `syntax.string` \| all, AsciiDoc \|
60	61	\| `char` \| `syntax.char` \| Golo (`'c'`) \|
61	62	\| `number` \| `syntax.number` \| Golo, TOML, JavaScript, shell, YAML, Dockerfile \|
62		-\| `comment` \| `syntax.comment` \| Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile \|
	63	+\| `comment` \| `syntax.comment` \| Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile, AsciiDoc \|
63	64	\| `operator` \| `syntax.operator` \| Golo, TOML, JavaScript, shell, HTML, YAML (block scalar headers), XML, Dockerfile \|
64		-\| `punctuation` \| `syntax.punctuation` \| Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile \|
65		-\| `heading` \| `syntax.heading` \| Markdown \|
	65	+\| `punctuation` \| `syntax.punctuation` \| Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile, AsciiDoc \|
	66	+\| `heading` \| `syntax.heading` \| Markdown, AsciiDoc \|
66	67	\| `tag` \| `syntax.tag` \| HTML, XML \|
67		-\| `attribute` \| `syntax.attribute` \| HTML, XML, Dockerfile (flags) \|
68		-\| `emphasis` \| `syntax.emphasis` \| Markdown \|
69		-\| `link` \| `syntax.link` \| Markdown \|
	68	+\| `attribute` \| `syntax.attribute` \| HTML, XML, Dockerfile (flags), AsciiDoc \|
	69	+\| `emphasis` \| `syntax.emphasis` \| Markdown, AsciiDoc \|
	70	+\| `link` \| `syntax.link` \| Markdown, AsciiDoc \|
70	71
71	72	Golo produces no `heading`, `tag`, `attribute`, `emphasis` or `link` span. In `turbo-classic`, `syntax.number` and `syntax.constant` are both magenta and `syntax.char` is the green of `syntax.string`, so `42` and `true` share a colour there and so do `'x'` and `"x"`; other themes separate them. See [how to write your own theme](../how-to/write-a-theme.md) if you want to change it.
72	73
@@ -185,6 +186,28 @@ A fenced block is one colour whatever language it announces: ```` ```golo ``
185	186
186	187	The run of markers opening emphasis must be matched by a run of the same length, so `bold` is one span rather than two italics.
187	188
	189	+## AsciiDoc
	190	+
	191	+\| Recognised \| As \|
	192	+\| --- \| --- \|
	193	+\| `= Title` … `====== Title`, and `# Title` … `###### Title` \| the whole line as a heading \|
	194	+\| `bold`, `bold`, `_italic_`, `__italic__` \| emphasis \|
	195	+\| `` `mono` `` \| string \|
	196	+\| `https://…`, `link:…[text]`, `xref:…[text]`, `mailto:…[]`, `image:…[]`, `<<anchor>>`, `<<anchor,text>>` \| the whole thing as a link \|
	197	+\| `image::…[]`, `include::…[]`, `toc::[]` on a line of their own \| the whole line as a link \|
	198	+\| `{attribute}` \| constant \|
	199	+\| `:name: value`, `:name!:` \| the `:name:` as attribute; the value as prose \|
	200	+\| `[source,go]`, `[NOTE]`, `[[anchor]]` on a line of their own \| the whole line as attribute \|
	201	+\| `NOTE:`, `TIP:`, `IMPORTANT:`, `WARNING:`, `CAUTION:` \| the label as keyword \|
	202	+\| `.Block title` \| emphasis \|
	203	+\| `* `, `** `, `- `, `. `, `.. `, `1. ` \| the marker as punctuation \|
	204	+\| `====`, `****`, `____`, `--`, `\|===` \| punctuation; the lines between them are prose \|
	205	+\| `\|` in a table row \| punctuation; the cells are prose \|
	206	+\| `----`, `....`, `++++` blocks \| the whole block, delimiters included, as a string \|
	207	+\| `////` blocks and `//` lines \| comment \|
	208	+
	209	+A verbatim block is one colour whatever its `[source]` says, and it closes only on a delimiter of the same length — AsciiDoc's own rule, and what lets a listing contain a line of dashes. An unclosed one colours to the end of the file. Bold, italic and monospace follow the Markdown rules above, marker runs matched by length. Not recognised: literal paragraphs (indented lines), description lists (`term:: text`), `+passthrough+`, `#highlight#` — and `.asc` files, which are PGP signatures as often as documents.
	210	+
188	211	## JavaScript
189	212
190	213	\| Recognised \| As \|

  | `.toml` | TOML |
  | `.yaml`, `.yml` | YAML |
  | `.md`, `.markdown` | Markdown |
++| `.adoc`, `.asciidoc` | AsciiDoc |
  | `.js`, `.mjs`, `.cjs` | JavaScript |
  | `.html`, `.htm` | HTML |
  | `.xml`, `.xsd`, `.xsl`, `.xslt`, `.svg`, `.plist`, `.csproj`, `.pom` | XML |
  | Class | Theme key | Produced by |
  | --- | --- | --- |
  | `identifier` | `syntax.identifier` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
--| `keyword` | `syntax.keyword` | Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile |
++| `keyword` | `syntax.keyword` | Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile, AsciiDoc |
  | `type` | `syntax.type` | Golo (capitalised names and module paths), TOML (table headers), YAML (tags) |
  | `builtin` | `syntax.builtin` | Golo (the interpreter's functions), JavaScript, shell (builtins and expansions), YAML (anchors and aliases), Dockerfile (variables) |
--| `constant` | `syntax.constant` | Golo, TOML, JavaScript, shell, YAML, HTML and XML (entities) |
++| `constant` | `syntax.constant` | Golo, TOML, JavaScript, shell, YAML, HTML and XML (entities), AsciiDoc |
  | `function` | `syntax.function` | Golo, JavaScript, shell (the command) |
--| `string` | `syntax.string` | all |
++| `string` | `syntax.string` | all, AsciiDoc |
  | `char` | `syntax.char` | Golo (`'c'`) |
  | `number` | `syntax.number` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
--| `comment` | `syntax.comment` | Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile |
++| `comment` | `syntax.comment` | Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile, AsciiDoc |
  | `operator` | `syntax.operator` | Golo, TOML, JavaScript, shell, HTML, YAML (block scalar headers), XML, Dockerfile |
--| `punctuation` | `syntax.punctuation` | Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile |
++| `punctuation` | `syntax.punctuation` | Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile, AsciiDoc |
--| `heading` | `syntax.heading` | Markdown |
++| `heading` | `syntax.heading` | Markdown, AsciiDoc |
  | `tag` | `syntax.tag` | HTML, XML |
--| `attribute` | `syntax.attribute` | HTML, XML, Dockerfile (flags) |
++| `attribute` | `syntax.attribute` | HTML, XML, Dockerfile (flags), AsciiDoc |
--| `emphasis` | `syntax.emphasis` | Markdown |
++| `emphasis` | `syntax.emphasis` | Markdown, AsciiDoc |
--| `link` | `syntax.link` | Markdown |
++| `link` | `syntax.link` | Markdown, AsciiDoc |
  Golo produces no `heading`, `tag`, `attribute`, `emphasis` or `link` span. In `turbo-classic`, `syntax.number` and `syntax.constant` are both magenta and `syntax.char` is the green of `syntax.string`, so `42` and `true` share a colour there and so do `'x'` and `"x"`; other themes separate them. See [how to write your own theme](../how-to/write-a-theme.md) if you want to change it.
  The run of markers opening emphasis must be matched by a run of the same length, so `**bold**` is one span rather than two italics.
++## AsciiDoc
++
++| Recognised | As |
++| --- | --- |
++| `= Title` … `====== Title`, and `# Title` … `###### Title` | the whole line as a heading |
++| `*bold*`, `**bold**`, `_italic_`, `__italic__` | emphasis |
++| `` `mono` `` | string |
++| `https://…`, `link:…[text]`, `xref:…[text]`, `mailto:…[]`, `image:…[]`, `<<anchor>>`, `<<anchor,text>>` | the whole thing as a link |
++| `image::…[]`, `include::…[]`, `toc::[]` on a line of their own | the whole line as a link |
++| `{attribute}` | constant |
++| `:name: value`, `:name!:` | the `:name:` as attribute; the value as prose |
++| `[source,go]`, `[NOTE]`, `[[anchor]]` on a line of their own | the whole line as attribute |
++| `NOTE:`, `TIP:`, `IMPORTANT:`, `WARNING:`, `CAUTION:` | the label as keyword |
++| `.Block title` | emphasis |
++| `* `, `** `, `- `, `. `, `.. `, `1. ` | the marker as punctuation |
++| `====`, `****`, `____`, `--`, `|===` | punctuation; the lines between them are prose |
++| `|` in a table row | punctuation; the cells are prose |
++| `----`, `....`, `++++` blocks | the whole block, delimiters included, as a string |
++| `////` blocks and `//` lines | comment |
++
++A verbatim block is **one colour whatever its `[source]` says**, and it closes only on a delimiter of the **same length** — AsciiDoc's own rule, and what lets a listing contain a line of dashes. An unclosed one colours to the end of the file. Bold, italic and monospace follow the Markdown rules above, marker runs matched by length. Not recognised: literal paragraphs (indented lines), description lists (`term:: text`), `+passthrough+`, `#highlight#` — and `.asc` files, which are PGP signatures as often as documents.
++
  ## JavaScript
  | Recognised | As |

modified docs/en/reference/terminal.md +25 -4 Viewed

@@ -35,7 +35,7 @@ Neither requires a file to be open. A tool in `.turbo-golo/tools.toml` whose `ou
35	35
36	36	### After the program has gone
37	37
38		-A window whose command has finished keeps its output, but stops behaving like a terminal: only `Shift-PgUp` and `Shift-PgDn` are still taken, and every other key reaches the editor — which is what lets `Ctrl-W` close it.
	38	+A window whose command has finished keeps its output, but stops behaving like a terminal: only the history and selection keys — `Shift-PgUp`, `Shift-PgDn`, `Shift-↑`, `Shift-↓`, `Ctrl-Ins` and `Shift-Ins` — are still taken, so what it printed can still be selected and copied (nothing can be pasted into it), and every other key reaches the editor — which is what lets `Ctrl-W` close it.
39	39
40	40	### Sent to the shell
41	41
@@ -76,18 +76,37 @@ Function keys therefore never reach a program inside a terminal window.
76	76	\| --- \| --- \|
77	77	\| `Shift-PgUp` \| Back one screenful through the history \|
78	78	\| `Shift-PgDn` \| Forward one screenful \|
	79	+\| `Shift-↑` `Shift-↓` \| Select whole lines: from the shell's cursor line with nothing selected, otherwise one more line up or down. A mouse selection becomes whole lines \|
	80	+\| `Ctrl-Ins` \| Copy the selection to the editor's clipboard and the system's, and drop it. Claimed even with nothing selected, so it never reaches the shell as `Insert` \|
	81	+\| `Shift-Ins` \| Type the editor's clipboard into the shell (see [Copying and pasting](#copying-and-pasting)). Claimed even when the clipboard is empty \|
79	82
80		-Any key sent to the shell also returns the view to the live screen.
	83	+Any key sent to the shell also returns the view to the live screen. `Shift-↑` and `Shift-↓` therefore never reach a program: a program that wanted them gets nothing.
81	84
82	85	## Mouse
83	86
84	87	\| Action \| Effect \|
85	88	\| --- \| --- \|
86	89	\| Wheel up / down \| Scroll three lines through the history \|
87		-\| Click \| Brings the window forward; not forwarded to the program \|
	90	+\| Click \| Brings the window forward and drops any selection; not forwarded to the program \|
	91	+\| Drag with the left button \| Selects the text between the press and the pointer, character by character across lines. Dragging past the window's edge selects up to that edge \|
88	92
89	93	Mouse reporting is not implemented, so a program is never told about clicks.
90	94
	95	+## Copying and pasting
	96	+
	97	+\| Property \| Value \|
	98	+\| --- \| --- \|
	99	+\| Selection \| Two cells of the whole text — history and live screen together — so it stays on the same text while the shell writes below it \|
	100	+\| Highlight \| The theme's `editor.selection`, replacing the program's colours inside the selection \|
	101	+\| Copied text \| The selected cells, lines joined with `\n`. A line selected to its right edge loses its trailing blanks; one selected short of the edge keeps every blank chosen \|
	102	+\| Copy goes to \| The editor's clipboard, and the system's through OSC 52 (unverified: the terminal may refuse it) \|
	103	+\| Status bar \| `Copied N lines` \|
	104	+\| Pasted text \| Each `\n` or `\r\n` becomes `\r`, as `Enter` sends. With private mode 2004 on, the whole is wrapped in `ESC [ 200 ~` … `ESC [ 201 ~` \|
	105	+\| Sources of a paste \| `Shift-Ins` and Edit ▸ Paste (the editor's clipboard); a bracketed paste from the terminal the editor runs in, handed over whole \|
	106	+\| Selection dropped by \| A copy, a paste, a click, a new drag \|
	107	+\| Selection kept across \| Output arriving, scrolling, keys sent to the shell \|
	108	+\| Not selectable \| Nothing: the alternate screen and a finished window can both be selected from \|
	109	+
91	110	## History
92	111
93	112	\| Property \| Value \|
@@ -157,6 +176,7 @@ Set with `CSI ? n h`, cleared with `CSI ? n l`.
157	176	\| 47, 1047 \| \| Alternate screen \|
158	177	\| 1048 \| \| Save / restore the cursor \|
159	178	\| 1049 \| \| Save the cursor, then the alternate screen \|
	179	+\| 2004 \| \| Bracketed paste: a paste into the window is wrapped in `ESC [ 200 ~` … `ESC [ 201 ~` \|
160	180
161	181	Any other mode is parsed and ignored.
162	182
@@ -202,7 +222,7 @@ Parsed correctly, so they never appear as stray characters, but with no effect:
202	222
203	223	### Not implemented
204	224
205		-Mouse reporting, bracketed paste, shift-in / shift-out, double-width lines, sixel and other graphics protocols, and the DEC status and device-attribute reports. A program that asks for one of these gets no reply, so a program that waits for one waits forever.
	225	+Mouse reporting, shift-in / shift-out, double-width lines, sixel and other graphics protocols, and the DEC status and device-attribute reports. A program that asks for one of these gets no reply, so a program that waits for one waits forever.
206	226
207	227	## Colours
208	228
@@ -210,6 +230,7 @@ Mouse reporting, bracketed paste, shift-in / shift-out, double-width lines, sixe
210	230	\| --- \| --- \|
211	231	\| `terminal.text` \| Every cell whose colour the program did not choose \|
212	232	\| `terminal.cursor` \| The cell under the cursor, when the window has the focus \|
	233	+\| `editor.selection` \| The selected cells — the same colour as a selection in a file \|
213	234
214	235	See [Theme file format](themes.md).
215	236

  ### After the program has gone
--A window whose command has finished keeps its output, but stops behaving like a terminal: only `Shift-PgUp` and `Shift-PgDn` are still taken, and every other key reaches the editor — which is what lets `Ctrl-W` close it.
++A window whose command has finished keeps its output, but stops behaving like a terminal: only the history and selection keys — `Shift-PgUp`, `Shift-PgDn`, `Shift-↑`, `Shift-↓`, `Ctrl-Ins` and `Shift-Ins` — are still taken, so what it printed can still be selected and copied (nothing can be pasted into it), and every other key reaches the editor — which is what lets `Ctrl-W` close it.
  ### Sent to the shell
  | --- | --- |
  | `Shift-PgUp` | Back one screenful through the history |
  | `Shift-PgDn` | Forward one screenful |
++| `Shift-↑` `Shift-↓` | Select whole lines: from the shell's cursor line with nothing selected, otherwise one more line up or down. A mouse selection becomes whole lines |
++| `Ctrl-Ins` | Copy the selection to the editor's clipboard and the system's, and drop it. Claimed even with nothing selected, so it never reaches the shell as `Insert` |
++| `Shift-Ins` | Type the editor's clipboard into the shell (see [Copying and pasting](#copying-and-pasting)). Claimed even when the clipboard is empty |
--Any key sent to the shell also returns the view to the live screen.
++Any key sent to the shell also returns the view to the live screen. `Shift-↑` and `Shift-↓` therefore never reach a program: a program that wanted them gets nothing.
  ## Mouse
  | Action | Effect |
  | --- | --- |
  | Wheel up / down | Scroll three lines through the history |
--| Click | Brings the window forward; not forwarded to the program |
++| Click | Brings the window forward and drops any selection; not forwarded to the program |
++| Drag with the left button | Selects the text between the press and the pointer, character by character across lines. Dragging past the window's edge selects up to that edge |
  Mouse reporting is not implemented, so a program is never told about clicks.
++## Copying and pasting
++
++| Property | Value |
++| --- | --- |
++| Selection | Two cells of the whole text — history and live screen together — so it stays on the same text while the shell writes below it |
++| Highlight | The theme's `editor.selection`, replacing the program's colours inside the selection |
++| Copied text | The selected cells, lines joined with `\n`. A line selected to its right edge loses its trailing blanks; one selected short of the edge keeps every blank chosen |
++| Copy goes to | The editor's clipboard, and the system's through OSC 52 (unverified: the terminal may refuse it) |
++| Status bar | `Copied N lines` |
++| Pasted text | Each `\n` or `\r\n` becomes `\r`, as `Enter` sends. With private mode 2004 on, the whole is wrapped in `ESC [ 200 ~` … `ESC [ 201 ~` |
++| Sources of a paste | `Shift-Ins` and **Edit ▸ Paste** (the editor's clipboard); a bracketed paste from the terminal the editor runs in, handed over whole |
++| Selection dropped by | A copy, a paste, a click, a new drag |
++| Selection kept across | Output arriving, scrolling, keys sent to the shell |
++| Not selectable | Nothing: the alternate screen and a finished window can both be selected from |
++
  ## History
  | Property | Value |
  | 47, 1047 | | Alternate screen |
  | 1048 | | Save / restore the cursor |
  | 1049 | | Save the cursor, then the alternate screen |
++| 2004 | | Bracketed paste: a paste into the window is wrapped in `ESC [ 200 ~` … `ESC [ 201 ~` |
  Any other mode is parsed and ignored.
  ### Not implemented
--Mouse reporting, bracketed paste, shift-in / shift-out, double-width lines, sixel and other graphics protocols, and the DEC status and device-attribute reports. A program that asks for one of these gets no reply, so a program that waits for one waits forever.
++Mouse reporting, shift-in / shift-out, double-width lines, sixel and other graphics protocols, and the DEC status and device-attribute reports. A program that asks for one of these gets no reply, so a program that waits for one waits forever.
  ## Colours
  | --- | --- |
  | `terminal.text` | Every cell whose colour the program did not choose |
  | `terminal.cursor` | The cell under the cursor, when the window has the focus |
++| `editor.selection` | The selected cells — the same colour as a selection in a file |
  See [Theme file format](themes.md).

modified docs/en/reference/themes.md +1 -1 Viewed

@@ -177,7 +177,7 @@ These are separate from the `list.*` keys on purpose: a dialog's list is coloure
177	177
178	178	### Syntax
179	179
180		-The examples are Golo's; the other eight languages map their own constructs onto the same classes.
	180	+The examples are Golo's; the other nine languages map their own constructs onto the same classes.
181	181
182	182	\| Key \| What it colours \|
183	183	\| --- \| --- \|

  ### Syntax
--The examples are Golo's; the other eight languages map their own constructs onto the same classes.
++The examples are Golo's; the other nine languages map their own constructs onto the same classes.
  | Key | What it colours |
  | --- | --- |

modified docs/fr/explanation/architecture.md +1 -1 Viewed

@@ -56,7 +56,7 @@ Tout ce qui serait sinon un `"turbo-golo"`, un `"golo"` ou un `".golo"` codé en
56	56
57	57	## Pourquoi le scanner est ici et pas dans la bibliothèque
58	58
59		-turbo-core colore huit langages lui-même : TOML, YAML, Markdown, JavaScript, HTML, XML, les Dockerfiles et le shell. Ce sont ceux que tout éditeur rencontre quel que soit son langage — la configuration d'un projet est en TOML ou en YAML, sa documentation en Markdown, ses scripts en shell, la construction de son image dans un Dockerfile.
	59	+turbo-core colore neuf langages lui-même : TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, les Dockerfiles et le shell. Ce sont ceux que tout éditeur rencontre quel que soit son langage — la configuration d'un projet est en TOML ou en YAML, sa documentation en Markdown, ses scripts en shell, la construction de son image dans un Dockerfile.
60	60
61	61	Golo n'en fait pas partie, ni Go, ni Rust, ni Python, ni MoonBit. Le langage qui définit un éditeur est enregistré par cet éditeur, et c'est pourquoi un fichier `.mbt` s'ouvre en texte brut ici et un fichier `.golo` s'ouvre en texte brut dans Turbo MoonBit.
62	62

  ## Pourquoi le scanner est ici et pas dans la bibliothèque
--turbo-core colore huit langages lui-même : TOML, YAML, Markdown, JavaScript, HTML, XML, les Dockerfiles et le shell. Ce sont ceux que tout éditeur rencontre quel que soit son langage — la configuration d'un projet est en TOML ou en YAML, sa documentation en Markdown, ses scripts en shell, la construction de son image dans un Dockerfile.
++turbo-core colore neuf langages lui-même : TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, les Dockerfiles et le shell. Ce sont ceux que tout éditeur rencontre quel que soit son langage — la configuration d'un projet est en TOML ou en YAML, sa documentation en Markdown, ses scripts en shell, la construction de son image dans un Dockerfile.
  Golo n'en fait pas partie, ni Go, ni Rust, ni Python, ni MoonBit. Le langage qui *définit* un éditeur est enregistré par cet éditeur, et c'est pourquoi un fichier `.mbt` s'ouvre en texte brut ici et un fichier `.golo` s'ouvre en texte brut dans Turbo MoonBit.

modified docs/fr/explanation/colouring-and-completion.md +3 -3 Viewed

@@ -20,7 +20,7 @@ On ne peut pas l'importer. Le `go.mod` de GoloScript dit `module golo` : un nom
20	20
21	21	Le lexer est donc la spécification plutôt qu'une dépendance. `lexer/lexer.go` et `token/token.go` disent ce qu'est un token — quelles runes ouvrent un commentaire, comment un nombre se termine, quels mots sont réservés — et ce scanner dit la même chose dans le style `LineScanner` de la bibliothèque. Là où les deux pourraient diverger, la ligne du lexer est citée dans le code à côté de la décision.
22	22
23		-Ce sera donc le scanner. Quelque six cents lignes, un fichier chacun pour le répartiteur, les littéraux et les mots — et aucune tentative de moteur général. Il n'y a ni langage de motifs, ni format de grammaire, ni table d'expressions régulières : c'est du Go ordinaire qu'un lecteur peut suivre, la règle que suivent les huit scanners de turbo-core.
	23	+Ce sera donc le scanner. Quelque six cents lignes, un fichier chacun pour le répartiteur, les littéraux et les mots — et aucune tentative de moteur général. Il n'y a ni langage de motifs, ni format de grammaire, ni table d'expressions régulières : c'est du Go ordinaire qu'un lecteur peut suivre, la règle que suivent les neuf scanners de turbo-core.
24	24
25	25	## Ce qui franchit une ligne, et pourquoi c'est porté plutôt que coupé
26	26
@@ -75,9 +75,9 @@ Là où une construction ne peut pas être reconnue à partir de ce qu'une ligne
75	75	\| Les échappements dans `"""…"""` \| Le lexer ajoute chaque rune jusqu'aux trois guillemets, `"""a\"""` se termine donc au premier `"""` quoi que la barre oblique inverse ait voulu dire \|
76	76	\| Si un nom est lié dans cette portée \| Rien ici ne lit plus d'une ligne à la fois ; c'est la question du serveur de langage, et [F1 y répond](../how-to/ask-about-code.md) \|
77	77
78		-## Les huit autres langages viennent gratuitement
	78	+## Les neuf autres langages viennent gratuitement
79	79
80		-TOML, YAML, Markdown, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés par turbo-core, pas ici. Un projet Golo a un `README.md`, un `compose.yaml` pour le service auquel il parle, un Dockerfile pour être livré, et un éditeur qui ne colorerait que les fichiers `.golo` vous ferait le quitter pour le reste.
	80	+TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés par turbo-core, pas ici. Un projet Golo a un `README.md`, un `compose.yaml` pour le service auquel il parle, un Dockerfile pour être livré, et un éditeur qui ne colorerait que les fichiers `.golo` vous ferait le quitter pour le reste.
81	81
82	82	Qu'ils soient partagés plutôt que copiés est tout l'intérêt de la bibliothèque : ils ont été écrits une fois, pour Turbo Go, et Turbo Golo les a obtenus en important un paquet.
83	83

  Le lexer est donc la **spécification** plutôt qu'une dépendance. `lexer/lexer.go` et `token/token.go` disent ce qu'est un token — quelles runes ouvrent un commentaire, comment un nombre se termine, quels mots sont réservés — et ce scanner dit la même chose dans le style `LineScanner` de la bibliothèque. Là où les deux pourraient diverger, la ligne du lexer est citée dans le code à côté de la décision.
--Ce sera donc le scanner. Quelque six cents lignes, un fichier chacun pour le répartiteur, les littéraux et les mots — et aucune tentative de moteur général. Il n'y a ni langage de motifs, ni format de grammaire, ni table d'expressions régulières : c'est du Go ordinaire qu'un lecteur peut suivre, la règle que suivent les huit scanners de turbo-core.
++Ce sera donc le scanner. Quelque six cents lignes, un fichier chacun pour le répartiteur, les littéraux et les mots — et aucune tentative de moteur général. Il n'y a ni langage de motifs, ni format de grammaire, ni table d'expressions régulières : c'est du Go ordinaire qu'un lecteur peut suivre, la règle que suivent les neuf scanners de turbo-core.
  ## Ce qui franchit une ligne, et pourquoi c'est porté plutôt que coupé
  | Les échappements dans `"""…"""` | Le lexer ajoute chaque rune jusqu'aux trois guillemets, `"""a\"""` se termine donc au premier `"""` quoi que la barre oblique inverse ait voulu dire |
  | Si un nom est lié dans cette portée | Rien ici ne lit plus d'une ligne à la fois ; c'est la question du serveur de langage, et [F1 y répond](../how-to/ask-about-code.md) |
--## Les huit autres langages viennent gratuitement
++## Les neuf autres langages viennent gratuitement
--TOML, YAML, Markdown, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés par turbo-core, pas ici. Un projet Golo a un `README.md`, un `compose.yaml` pour le service auquel il parle, un Dockerfile pour être livré, et un éditeur qui ne colorerait que les fichiers `.golo` vous ferait le quitter pour le reste.
++TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés par turbo-core, pas ici. Un projet Golo a un `README.md`, un `compose.yaml` pour le service auquel il parle, un Dockerfile pour être livré, et un éditeur qui ne colorerait que les fichiers `.golo` vous ferait le quitter pour le reste.
  Qu'ils soient partagés plutôt que copiés est tout l'intérêt de la bibliothèque : ils ont été écrits une fois, pour Turbo Go, et Turbo Golo les a obtenus en important un paquet.

modified docs/fr/explanation/terminal-windows.md +8 -0 Viewed

@@ -38,6 +38,14 @@ Ces exceptions ne sont pas un compromis entre les deux revendications — ce son
38	38
39	39	Ce que cela coûte est réel et mérite d'être nommé : `Alt-B` et `Alt-F` atteignent le shell, donc le déplacement par mot de readline fonctionne, mais un programme dans une fenêtre terminal ne verra jamais `F1`…`F12`. Le menu par touches de fonction de `htop` est inaccessible. C'est l'arbitrage, et il a été rendu en faveur du fait de toujours pouvoir sortir.
40	40
	41	+## Copier vers l'extérieur, coller vers l'intérieur
	42	+
	43	+La sortie d'un terminal est voulue ailleurs aussi souvent qu'elle est lue : un chemin tiré d'une erreur de compilation, une ligne d'une trace, le résultat d'une commande à coller dans le fichier voisin. Et dans l'autre sens, une commande écrite dans un fichier et voulue à l'invite. Les deux touches évidentes sont indisponibles, et la section précédente dit pourquoi : `Ctrl-C` interrompt et `Ctrl-V` est le quoted-insert de readline, et un terminal qui prendrait l'une ou l'autre serait un moins bon terminal. Le terminal a donc l'autre orthographe des deux mêmes commandes dans l'éditeur, `Ctrl-Inser` et `Maj-Inser`, que le menu Édition affiche déjà et dont aucun shell n'a l'usage — transmises, elles arriveraient l'une comme l'autre en simple `Insert` et basculeraient le mode écrasement.
	44	+
	45	+La sélection est mémorisée comme deux cellules du texte entier, historique et écran vivant réunis, plutôt que comme des positions d'écran. C'est ce qui lui permet de survivre à ce que le shell écrit en dessous : une ligne qui sort par le haut vers l'historique garde son indice, parce que l'historique grandit exactement de la ligne que l'écran a perdue. La sélection au clavier se fait par lignes entières, comme dans la fenêtre agent et pour la même raison — rien n'est édité ici, et une ligne entière est presque toujours ce qu'on voulait ; la souris sélectionne au caractère parce qu'un chemin au milieu d'une ligne est l'autre chose que l'on veut. La copie va dans les deux presse-papiers, celui de l'éditeur et celui du système, là encore comme dans la fenêtre agent et pour la même raison : « copie ça » depuis un terminal veut généralement dire l'emporter tout à fait hors de l'éditeur.
	46	+
	47	+Le collage est le seul endroit où la frontière de l'émulateur a bougé. Un collage est tapé dans le shell avec `Entrée` pour chaque fin de ligne, ce que fait un terminal ; mais `bash`, `zsh` et `fish` demandent tous le collage entre crochets — le mode privé 2004 — précisément pour qu'un collage multiligne arrive comme un bloc à éditer plutôt que comme des lignes à exécuter. L'émulateur ignorait ce mode avec les autres. Il le mémorise désormais, et rien de plus : il ne colle toujours jamais de lui-même, mais quand l'éditeur colle pour le compte de l'utilisateur, il peut encadrer le texte des marques demandées par le shell. Un collage venu de l'extérieur de l'éditeur dans une fenêtre terminal est transmis de la même façon, entier, plutôt que rejoué touche par touche — la règle que suit déjà la zone de saisie de la fenêtre agent.
	48	+
41	49	## Pourquoi fermer un terminal ne demande rien
42	50
43	51	Fermer un fichier modifié demande s'il faut l'enregistrer. Fermer un terminal ne demande rien du tout, et cette asymétrie est délibérée.

  Ce que cela coûte est réel et mérite d'être nommé : `Alt-B` et `Alt-F` atteignent le shell, donc le déplacement par mot de readline fonctionne, mais un programme dans une fenêtre terminal ne verra jamais `F1`…`F12`. Le menu par touches de fonction de `htop` est inaccessible. C'est l'arbitrage, et il a été rendu en faveur du fait de toujours pouvoir sortir.
++## Copier vers l'extérieur, coller vers l'intérieur
++
++La sortie d'un terminal est voulue ailleurs aussi souvent qu'elle est lue : un chemin tiré d'une erreur de compilation, une ligne d'une trace, le résultat d'une commande à coller dans le fichier voisin. Et dans l'autre sens, une commande écrite dans un fichier et voulue à l'invite. Les deux touches évidentes sont indisponibles, et la section précédente dit pourquoi : `Ctrl-C` interrompt et `Ctrl-V` est le quoted-insert de readline, et un terminal qui prendrait l'une ou l'autre serait un moins bon terminal. Le terminal a donc l'*autre* orthographe des deux mêmes commandes dans l'éditeur, `Ctrl-Inser` et `Maj-Inser`, que le menu Édition affiche déjà et dont aucun shell n'a l'usage — transmises, elles arriveraient l'une comme l'autre en simple `Insert` et basculeraient le mode écrasement.
++
++La sélection est mémorisée comme deux cellules du texte entier, historique et écran vivant réunis, plutôt que comme des positions d'écran. C'est ce qui lui permet de survivre à ce que le shell écrit en dessous : une ligne qui sort par le haut vers l'historique garde son indice, parce que l'historique grandit exactement de la ligne que l'écran a perdue. La sélection au clavier se fait par lignes entières, comme dans la fenêtre agent et pour la même raison — rien n'est édité ici, et une ligne entière est presque toujours ce qu'on voulait ; la souris sélectionne au caractère parce qu'un chemin au milieu d'une ligne est l'autre chose que l'on veut. La copie va dans les deux presse-papiers, celui de l'éditeur et celui du système, là encore comme dans la fenêtre agent et pour la même raison : « copie ça » depuis un terminal veut généralement dire l'emporter tout à fait hors de l'éditeur.
++
++Le collage est le seul endroit où la frontière de l'émulateur a bougé. Un collage est tapé dans le shell avec `Entrée` pour chaque fin de ligne, ce que fait un terminal ; mais `bash`, `zsh` et `fish` demandent tous le *collage entre crochets* — le mode privé 2004 — précisément pour qu'un collage multiligne arrive comme un bloc à éditer plutôt que comme des lignes à exécuter. L'émulateur ignorait ce mode avec les autres. Il le mémorise désormais, et rien de plus : il ne colle toujours jamais de lui-même, mais quand l'éditeur colle pour le compte de l'utilisateur, il peut encadrer le texte des marques demandées par le shell. Un collage venu de l'extérieur de l'éditeur dans une fenêtre terminal est transmis de la même façon, entier, plutôt que rejoué touche par touche — la règle que suit déjà la zone de saisie de la fenêtre agent.
++
  ## Pourquoi fermer un terminal ne demande rien
  Fermer un fichier modifié demande s'il faut l'enregistrer. Fermer un terminal ne demande rien du tout, et cette asymétrie est délibérée.

modified docs/fr/how-to/navigate-code.md +1 -1 Viewed

@@ -60,7 +60,7 @@ Si les fenêtres se recouvrent, `Window ▸ Tile` les dispose côte à côte et
60	60
61	61	## Variantes
62	62
63		-Le fichier n'est pas du Golo. Tout ce qui précède fonctionne sauf F12, qui a besoin d'un serveur de langage. La coloration dépend du langage : Golo — les fichiers `.golo`, et les scripts sans extension dont la première ligne est `#!/usr/bin/env golo` — ainsi que TOML, YAML, Markdown, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés ; un autre fichier ne l'est pas.
	63	+Le fichier n'est pas du Golo. Tout ce qui précède fonctionne sauf F12, qui a besoin d'un serveur de langage. La coloration dépend du langage : Golo — les fichiers `.golo`, et les scripts sans extension dont la première ligne est `#!/usr/bin/env golo` — ainsi que TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés ; un autre fichier ne l'est pas.
64	64
65	65	Vous voulez savoir où vous êtes. L'extrémité droite de la barre d'état affiche en permanence `ligne:colonne`, à partir de un.
66	66

  ## Variantes
--**Le fichier n'est pas du Golo.** Tout ce qui précède fonctionne sauf F12, qui a besoin d'un serveur de langage. La coloration dépend du langage : Golo — les fichiers `.golo`, et les scripts sans extension dont la première ligne est `#!/usr/bin/env golo` — ainsi que TOML, YAML, Markdown, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés ; un autre fichier ne l'est pas.
++**Le fichier n'est pas du Golo.** Tout ce qui précède fonctionne sauf F12, qui a besoin d'un serveur de langage. La coloration dépend du langage : Golo — les fichiers `.golo`, et les scripts sans extension dont la première ligne est `#!/usr/bin/env golo` — ainsi que TOML, YAML, Markdown, AsciiDoc, JavaScript, HTML, XML, les Dockerfiles et le shell sont colorés ; un autre fichier ne l'est pas.
  **Vous voulez savoir où vous êtes.** L'extrémité droite de la barre d'état affiche en permanence `ligne:colonne`, à partir de un.

modified docs/fr/how-to/use-a-terminal.md +15 -0 Viewed

@@ -31,6 +31,21 @@ Ce que l'éditeur conserve est court, et voulu — c'est le chemin de sortie :
31	31
32	32	Taper quoi que ce soit ramène directement à l'écran vivant : jamais besoin de redescendre avant de lancer la commande suivante.
33	33
	34	+## Copier depuis le terminal vers un fichier, et retour
	35	+
	36	+Le shell garde `Ctrl-C` et `Ctrl-V` ; le terminal utilise donc l'autre orthographe du copier-coller de l'éditeur, celle qu'affiche le menu Édition.
	37	+
	38	+Hors du terminal. Sélectionnez ce que vous voulez, puis appuyez sur `Ctrl-Inser` (ou choisissez Édition ▸ Copier) :
	39	+
	40	+- À la souris, faites glisser sur le texte. Un glissement qui dépasse le bord de la fenêtre continue de sélectionner jusqu'à ce bord.
	41	+- Au clavier, `Maj-↑` et `Maj-↓` sélectionnent des lignes entières, à partir de la ligne où se trouve le curseur du shell, une ligne à la fois.
	42	+
	43	+La sélection est surlignée, et la barre d'état dit combien de lignes ont été copiées. Le texte va dans le presse-papiers de l'éditeur et, si votre terminal le permet, dans celui du système aussi. Passez dans un fichier et appuyez sur `Maj-Inser` pour le coller. Une fenêtre dont la commande est terminée peut encore être sélectionnée et copiée.
	44	+
	45	+Dans le terminal. Copiez quelque chose dans un fichier — `Ctrl-Inser`, ou `Ctrl-C` là-bas —, passez le terminal au premier plan et appuyez sur `Maj-Inser` (ou Édition ▸ Coller). Le texte est tapé dans le shell avec une Entrée par fin de ligne, donc un collage multiligne s'exécute ligne par ligne — sauf si le shell a demandé le collage entre crochets, comme le font `bash`, `zsh` et `fish` : il reçoit alors le bloc entier à éditer avant de l'exécuter. Un collage venu de l'extérieur de l'éditeur dans une fenêtre terminal est transmis de la même façon.
	46	+
	47	+Un simple clic abandonne la sélection. `Ctrl-Inser` sans sélection ne fait rien, et n'atteint jamais le shell.
	48	+
34	49	## Travailler avec le fichier et le shell côte à côte
35	50
36	51	Un terminal est une fenêtre ordinaire, donc toutes les commandes de fenêtre s'y appliquent :

  Taper quoi que ce soit ramène directement à l'écran vivant : jamais besoin de redescendre avant de lancer la commande suivante.
++## Copier depuis le terminal vers un fichier, et retour
++
++Le shell garde `Ctrl-C` et `Ctrl-V` ; le terminal utilise donc l'autre orthographe du copier-coller de l'éditeur, celle qu'affiche le menu Édition.
++
++**Hors du terminal.** Sélectionnez ce que vous voulez, puis appuyez sur `Ctrl-Inser` (ou choisissez **Édition ▸ Copier**) :
++
++- **À la souris**, faites glisser sur le texte. Un glissement qui dépasse le bord de la fenêtre continue de sélectionner jusqu'à ce bord.
++- **Au clavier**, `Maj-↑` et `Maj-↓` sélectionnent des lignes entières, à partir de la ligne où se trouve le curseur du shell, une ligne à la fois.
++
++La sélection est surlignée, et la barre d'état dit combien de lignes ont été copiées. Le texte va dans le presse-papiers de l'éditeur et, si votre terminal le permet, dans celui du système aussi. Passez dans un fichier et appuyez sur `Maj-Inser` pour le coller. Une fenêtre dont la commande est terminée peut encore être sélectionnée et copiée.
++
++**Dans le terminal.** Copiez quelque chose dans un fichier — `Ctrl-Inser`, ou `Ctrl-C` là-bas —, passez le terminal au premier plan et appuyez sur `Maj-Inser` (ou **Édition ▸ Coller**). Le texte est tapé dans le shell avec une Entrée par fin de ligne, donc un collage multiligne s'exécute ligne par ligne — sauf si le shell a demandé le collage entre crochets, comme le font `bash`, `zsh` et `fish` : il reçoit alors le bloc entier à éditer avant de l'exécuter. Un collage venu de l'extérieur de l'éditeur dans une fenêtre terminal est transmis de la même façon.
++
++Un simple clic abandonne la sélection. `Ctrl-Inser` sans sélection ne fait rien, et n'atteint jamais le shell.
++
  ## Travailler avec le fichier et le shell côte à côte
  Un terminal est une fenêtre ordinaire, donc toutes les commandes de fenêtre s'y appliquent :

modified docs/fr/reference/keyboard.md +4 -0 Viewed

@@ -144,6 +144,9 @@ Une fenêtre terminal au premier plan reçoit toutes les touches sauf les to
144	144	\| Touche \| Action \|
145	145	\| --- \| --- \|
146	146	\| `Maj-Page↑` `Maj-Page↓` \| Reculer / avancer d'un écran dans l'historique \|
	147	+\| `Maj-↑` `Maj-↓` \| Sélectionner des lignes entières, depuis la ligne du curseur du shell \|
	148	+\| `Ctrl-Inser` \| Copier la sélection (aussi Édition ▸ Copier) \|
	149	+\| `Maj-Inser` \| Coller le presse-papiers de l'éditeur dans le shell (aussi Édition ▸ Coller) \|
147	150	\| toute autre touche non réservée ci-dessus \| Envoyée au shell, ramenant la vue à l'écran vivant \|
148	151
149	152	Les octets exacts envoyés par chaque touche sont dans [Fenêtres terminal](terminal.md).
@@ -176,4 +179,5 @@ Traitées quand la fenêtre de l'arbre a le focus. Les règles complètes sont d
176	179	\| Clic sur `[■]` \| Donner tout le bureau à la fenêtre \|
177	180	\| Clic sur `[▬]` \| Remettre une fenêtre agrandie à sa taille précédente \|
178	181	\| Molette sur un terminal \| Défiler de trois lignes dans son historique \|
	182	+\| Glisser sur un terminal \| Sélectionner du texte ; un clic abandonne la sélection \|
179	183	\| Clic sur une ligne d'arbre \| La surligner ; un second clic l'ouvre \|

  | Touche | Action |
  | --- | --- |
  | `Maj-Page↑` `Maj-Page↓` | Reculer / avancer d'un écran dans l'historique |
++| `Maj-↑` `Maj-↓` | Sélectionner des lignes entières, depuis la ligne du curseur du shell |
++| `Ctrl-Inser` | Copier la sélection (aussi **Édition ▸ Copier**) |
++| `Maj-Inser` | Coller le presse-papiers de l'éditeur dans le shell (aussi **Édition ▸ Coller**) |
  | toute autre touche non réservée ci-dessus | Envoyée au shell, ramenant la vue à l'écran vivant |
  Les octets exacts envoyés par chaque touche sont dans [Fenêtres terminal](terminal.md).
  | Clic sur `[■]` | Donner tout le bureau à la fenêtre |
  | Clic sur `[▬]` | Remettre une fenêtre agrandie à sa taille précédente |
  | Molette sur un terminal | Défiler de trois lignes dans son historique |
++| Glisser sur un terminal | Sélectionner du texte ; un clic abandonne la sélection |
  | Clic sur une ligne d'arbre | La surligner ; un second clic l'ouvre |

modified docs/fr/reference/languages.md +32 -9 Viewed

@@ -12,6 +12,7 @@ L'extension d'un fichier décide dès qu'elle est l'une de celles-ci :
12	12	\| `.toml` \| TOML \|
13	13	\| `.yaml`, `.yml` \| YAML \|
14	14	\| `.md`, `.markdown` \| Markdown \|
	15	+\| `.adoc`, `.asciidoc` \| AsciiDoc \|
15	16	\| `.js`, `.mjs`, `.cjs` \| JavaScript \|
16	17	\| `.html`, `.htm` \| HTML \|
17	18	\| `.xml`, `.xsd`, `.xsl`, `.xslt`, `.svg`, `.plist`, `.csproj`, `.pom` \| XML \|
@@ -51,22 +52,22 @@ Chaque scanner produit le même vocabulaire de classes, et chacune correspond à
51	52	\| Classe \| Clé de thème \| Produite par \|
52	53	\| --- \| --- \| --- \|
53	54	\| `identifier` \| `syntax.identifier` \| Golo, TOML, JavaScript, shell, YAML, Dockerfile \|
54		-\| `keyword` \| `syntax.keyword` \| Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile \|
	55	+\| `keyword` \| `syntax.keyword` \| Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile, AsciiDoc \|
55	56	\| `type` \| `syntax.type` \| Golo (noms capitalisés et chemins de module), TOML (en-têtes de table), YAML (tags) \|
56	57	\| `builtin` \| `syntax.builtin` \| Golo (les fonctions de l'interpréteur), JavaScript, shell (builtins et expansions), YAML (ancres et alias), Dockerfile (variables) \|
57		-\| `constant` \| `syntax.constant` \| Golo, TOML, JavaScript, shell, YAML, HTML et XML (entités) \|
	58	+\| `constant` \| `syntax.constant` \| Golo, TOML, JavaScript, shell, YAML, HTML et XML (entités), AsciiDoc \|
58	59	\| `function` \| `syntax.function` \| Golo, JavaScript, shell (la commande) \|
59		-\| `string` \| `syntax.string` \| tous \|
	60	+\| `string` \| `syntax.string` \| tous, AsciiDoc \|
60	61	\| `char` \| `syntax.char` \| Golo (`'c'`) \|
61	62	\| `number` \| `syntax.number` \| Golo, TOML, JavaScript, shell, YAML, Dockerfile \|
62		-\| `comment` \| `syntax.comment` \| Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile \|
	63	+\| `comment` \| `syntax.comment` \| Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile, AsciiDoc \|
63	64	\| `operator` \| `syntax.operator` \| Golo, TOML, JavaScript, shell, HTML, YAML (en-têtes de scalaires bloc), XML, Dockerfile \|
64		-\| `punctuation` \| `syntax.punctuation` \| Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile \|
65		-\| `heading` \| `syntax.heading` \| Markdown \|
	65	+\| `punctuation` \| `syntax.punctuation` \| Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile, AsciiDoc \|
	66	+\| `heading` \| `syntax.heading` \| Markdown, AsciiDoc \|
66	67	\| `tag` \| `syntax.tag` \| HTML, XML \|
67		-\| `attribute` \| `syntax.attribute` \| HTML, XML, Dockerfile (options) \|
68		-\| `emphasis` \| `syntax.emphasis` \| Markdown \|
69		-\| `link` \| `syntax.link` \| Markdown \|
	68	+\| `attribute` \| `syntax.attribute` \| HTML, XML, Dockerfile (options), AsciiDoc \|
	69	+\| `emphasis` \| `syntax.emphasis` \| Markdown, AsciiDoc \|
	70	+\| `link` \| `syntax.link` \| Markdown, AsciiDoc \|
70	71
71	72	Golo ne produit aucune portée `heading`, `tag`, `attribute`, `emphasis` ou `link`. Dans `turbo-classic`, `syntax.number` et `syntax.constant` sont tous deux magenta et `syntax.char` a le vert de `syntax.string`, si bien que `42` et `true` partagent une couleur là, et `'x'` et `"x"` aussi ; d'autres thèmes les séparent. Voir [écrire son propre thème](../how-to/write-a-theme.md) pour changer cela.
72	73
@@ -185,6 +186,28 @@ Un bloc clôturé est d'une seule couleur quel que soit le langage annoncé
185	186
186	187	La suite de marqueurs ouvrant une emphase doit être fermée par une suite de même longueur, `gras` est donc une portée plutôt que deux italiques.
187	188
	189	+## AsciiDoc
	190	+
	191	+\| Reconnu \| Comme \|
	192	+\| --- \| --- \|
	193	+\| `= Titre` … `====== Titre`, et `# Titre` … `###### Titre` \| toute la ligne en heading \|
	194	+\| `gras`, `gras`, `_italique_`, `__italique__` \| emphasis \|
	195	+\| `` `mono` `` \| string \|
	196	+\| `https://…`, `link:…[texte]`, `xref:…[texte]`, `mailto:…[]`, `image:…[]`, `<<ancre>>`, `<<ancre,texte>>` \| l'ensemble en link \|
	197	+\| `image::…[]`, `include::…[]`, `toc::[]` seuls sur leur ligne \| toute la ligne en link \|
	198	+\| `{attribut}` \| constant \|
	199	+\| `:nom: valeur`, `:nom!:` \| le `:nom:` en attribute ; la valeur en prose \|
	200	+\| `[source,go]`, `[NOTE]`, `[[ancre]]` seuls sur leur ligne \| toute la ligne en attribute \|
	201	+\| `NOTE:`, `TIP:`, `IMPORTANT:`, `WARNING:`, `CAUTION:` \| l'étiquette en keyword \|
	202	+\| `.Titre de bloc` \| emphasis \|
	203	+\| `* `, `** `, `- `, `. `, `.. `, `1. ` \| le marqueur en punctuation \|
	204	+\| `====`, `****`, `____`, `--`, `\|===` \| punctuation ; les lignes entre eux sont de la prose \|
	205	+\| `\|` dans une ligne de tableau \| punctuation ; les cellules sont de la prose \|
	206	+\| blocs `----`, `....`, `++++` \| tout le bloc, délimiteurs compris, en string \|
	207	+\| blocs `////` et lignes `//` \| comment \|
	208	+
	209	+Un bloc verbatim est d'une seule couleur quoi que dise son `[source]`, et ne se ferme que sur un délimiteur de même longueur — la règle d'AsciiDoc, et ce qui permet à un listing de contenir une ligne de tirets. Un bloc non fermé colore jusqu'à la fin du fichier. Gras, italique et monospace suivent les règles Markdown ci-dessus, suites de marqueurs appariées par longueur. Non reconnus : les paragraphes littéraux (lignes indentées), les listes de description (`terme:: texte`), `+passthrough+`, `#surlignage#` — et les fichiers `.asc`, aussi souvent des signatures PGP que des documents.
	210	+
188	211	## JavaScript
189	212
190	213	\| Reconnu \| Comme \|

  | `.toml` | TOML |
  | `.yaml`, `.yml` | YAML |
  | `.md`, `.markdown` | Markdown |
++| `.adoc`, `.asciidoc` | AsciiDoc |
  | `.js`, `.mjs`, `.cjs` | JavaScript |
  | `.html`, `.htm` | HTML |
  | `.xml`, `.xsd`, `.xsl`, `.xslt`, `.svg`, `.plist`, `.csproj`, `.pom` | XML |
  | Classe | Clé de thème | Produite par |
  | --- | --- | --- |
  | `identifier` | `syntax.identifier` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
--| `keyword` | `syntax.keyword` | Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile |
++| `keyword` | `syntax.keyword` | Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile, AsciiDoc |
  | `type` | `syntax.type` | Golo (noms capitalisés et chemins de module), TOML (en-têtes de table), YAML (tags) |
  | `builtin` | `syntax.builtin` | Golo (les fonctions de l'interpréteur), JavaScript, shell (builtins et expansions), YAML (ancres et alias), Dockerfile (variables) |
--| `constant` | `syntax.constant` | Golo, TOML, JavaScript, shell, YAML, HTML et XML (entités) |
++| `constant` | `syntax.constant` | Golo, TOML, JavaScript, shell, YAML, HTML et XML (entités), AsciiDoc |
  | `function` | `syntax.function` | Golo, JavaScript, shell (la commande) |
--| `string` | `syntax.string` | tous |
++| `string` | `syntax.string` | tous, AsciiDoc |
  | `char` | `syntax.char` | Golo (`'c'`) |
  | `number` | `syntax.number` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
--| `comment` | `syntax.comment` | Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile |
++| `comment` | `syntax.comment` | Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile, AsciiDoc |
  | `operator` | `syntax.operator` | Golo, TOML, JavaScript, shell, HTML, YAML (en-têtes de scalaires bloc), XML, Dockerfile |
--| `punctuation` | `syntax.punctuation` | Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile |
++| `punctuation` | `syntax.punctuation` | Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile, AsciiDoc |
--| `heading` | `syntax.heading` | Markdown |
++| `heading` | `syntax.heading` | Markdown, AsciiDoc |
  | `tag` | `syntax.tag` | HTML, XML |
--| `attribute` | `syntax.attribute` | HTML, XML, Dockerfile (options) |
++| `attribute` | `syntax.attribute` | HTML, XML, Dockerfile (options), AsciiDoc |
--| `emphasis` | `syntax.emphasis` | Markdown |
++| `emphasis` | `syntax.emphasis` | Markdown, AsciiDoc |
--| `link` | `syntax.link` | Markdown |
++| `link` | `syntax.link` | Markdown, AsciiDoc |
  Golo ne produit aucune portée `heading`, `tag`, `attribute`, `emphasis` ou `link`. Dans `turbo-classic`, `syntax.number` et `syntax.constant` sont tous deux magenta et `syntax.char` a le vert de `syntax.string`, si bien que `42` et `true` partagent une couleur là, et `'x'` et `"x"` aussi ; d'autres thèmes les séparent. Voir [écrire son propre thème](../how-to/write-a-theme.md) pour changer cela.
  La suite de marqueurs ouvrant une emphase doit être fermée par une suite de même longueur, `**gras**` est donc une portée plutôt que deux italiques.
++## AsciiDoc
++
++| Reconnu | Comme |
++| --- | --- |
++| `= Titre` … `====== Titre`, et `# Titre` … `###### Titre` | toute la ligne en heading |
++| `*gras*`, `**gras**`, `_italique_`, `__italique__` | emphasis |
++| `` `mono` `` | string |
++| `https://…`, `link:…[texte]`, `xref:…[texte]`, `mailto:…[]`, `image:…[]`, `<<ancre>>`, `<<ancre,texte>>` | l'ensemble en link |
++| `image::…[]`, `include::…[]`, `toc::[]` seuls sur leur ligne | toute la ligne en link |
++| `{attribut}` | constant |
++| `:nom: valeur`, `:nom!:` | le `:nom:` en attribute ; la valeur en prose |
++| `[source,go]`, `[NOTE]`, `[[ancre]]` seuls sur leur ligne | toute la ligne en attribute |
++| `NOTE:`, `TIP:`, `IMPORTANT:`, `WARNING:`, `CAUTION:` | l'étiquette en keyword |
++| `.Titre de bloc` | emphasis |
++| `* `, `** `, `- `, `. `, `.. `, `1. ` | le marqueur en punctuation |
++| `====`, `****`, `____`, `--`, `|===` | punctuation ; les lignes entre eux sont de la prose |
++| `|` dans une ligne de tableau | punctuation ; les cellules sont de la prose |
++| blocs `----`, `....`, `++++` | tout le bloc, délimiteurs compris, en string |
++| blocs `////` et lignes `//` | comment |
++
++Un bloc verbatim est **d'une seule couleur quoi que dise son `[source]`**, et ne se ferme que sur un délimiteur de **même longueur** — la règle d'AsciiDoc, et ce qui permet à un listing de contenir une ligne de tirets. Un bloc non fermé colore jusqu'à la fin du fichier. Gras, italique et monospace suivent les règles Markdown ci-dessus, suites de marqueurs appariées par longueur. Non reconnus : les paragraphes littéraux (lignes indentées), les listes de description (`terme:: texte`), `+passthrough+`, `#surlignage#` — et les fichiers `.asc`, aussi souvent des signatures PGP que des documents.
++
  ## JavaScript
  | Reconnu | Comme |

modified docs/fr/reference/terminal.md +25 -4 Viewed

@@ -35,7 +35,7 @@ Aucun des deux n'exige qu'un fichier soit ouvert. Les outils du menu Golo do
35	35
36	36	### Après la fin du programme
37	37
38		-Une fenêtre dont la commande est terminée garde sa sortie mais cesse de se comporter comme un terminal : seules `Maj-Page↑` et `Maj-Page↓` sont encore prises, et toute autre touche atteint l'éditeur — c'est ce qui permet à `Ctrl-W` de la fermer.
	38	+Une fenêtre dont la commande est terminée garde sa sortie mais cesse de se comporter comme un terminal : seules les touches d'historique et de sélection — `Maj-Page↑`, `Maj-Page↓`, `Maj-↑`, `Maj-↓`, `Ctrl-Inser` et `Maj-Inser` — sont encore prises, de sorte que ce qu'elle a affiché peut encore être sélectionné et copié (rien ne peut y être collé), et toute autre touche atteint l'éditeur — c'est ce qui permet à `Ctrl-W` de la fermer.
39	39
40	40	### Envoyées au shell
41	41
@@ -76,18 +76,37 @@ Les touches de fonction n'atteignent donc jamais un programme lancé dans une fe
76	76	\| --- \| --- \|
77	77	\| `Shift-PgUp` \| Reculer d'un écran dans l'historique \|
78	78	\| `Shift-PgDn` \| Avancer d'un écran \|
	79	+\| `Maj-↑` `Maj-↓` \| Sélectionner des lignes entières : depuis la ligne du curseur du shell sans sélection, sinon une ligne de plus vers le haut ou le bas. Une sélection à la souris devient des lignes entières \|
	80	+\| `Ctrl-Inser` \| Copier la sélection dans le presse-papiers de l'éditeur et celui du système, puis l'abandonner. Prise même sans sélection, pour ne jamais atteindre le shell en `Insert` \|
	81	+\| `Maj-Inser` \| Taper le presse-papiers de l'éditeur dans le shell (voir [Copier et coller](#copier-et-coller)). Prise même si le presse-papiers est vide \|
79	82
80		-Toute touche envoyée au shell ramène également la vue à l'écran vivant.
	83	+Toute touche envoyée au shell ramène également la vue à l'écran vivant. `Maj-↑` et `Maj-↓` n'atteignent donc jamais un programme : celui qui les voudrait n'obtient rien.
81	84
82	85	## Souris
83	86
84	87	\| Action \| Effet \|
85	88	\| --- \| --- \|
86	89	\| Molette haut / bas \| Défiler de trois lignes dans l'historique \|
87		-\| Clic \| Passe la fenêtre au premier plan ; n'est pas transmis au programme \|
	90	+\| Clic \| Passe la fenêtre au premier plan et abandonne toute sélection ; n'est pas transmis au programme \|
	91	+\| Glisser avec le bouton gauche \| Sélectionne le texte entre le point d'appui et le pointeur, caractère par caractère d'une ligne à l'autre. Glisser au-delà du bord de la fenêtre sélectionne jusqu'à ce bord \|
88	92
89	93	Le rapport souris n'est pas implémenté : un programme n'est jamais informé des clics.
90	94
	95	+## Copier et coller
	96	+
	97	+\| Propriété \| Valeur \|
	98	+\| --- \| --- \|
	99	+\| Sélection \| Deux cellules du texte entier — historique et écran vivant réunis —, de sorte qu'elle reste sur le même texte pendant que le shell écrit en dessous \|
	100	+\| Surlignage \| La clé `editor.selection` du thème, qui remplace les couleurs du programme dans la sélection \|
	101	+\| Texte copié \| Les cellules sélectionnées, lignes jointes par `\n`. Une ligne sélectionnée jusqu'à son bord droit perd ses blancs de fin ; une ligne sélectionnée avant le bord garde chaque blanc choisi \|
	102	+\| Destination de la copie \| Le presse-papiers de l'éditeur, et celui du système via OSC 52 (non vérifié : le terminal peut le refuser) \|
	103	+\| Barre d'état \| `Copied N lines` \|
	104	+\| Texte collé \| Chaque `\n` ou `\r\n` devient `\r`, comme l'envoie `Entrée`. Avec le mode privé 2004 actif, le tout est encadré par `ESC [ 200 ~` … `ESC [ 201 ~` \|
	105	+\| Sources d'un collage \| `Maj-Inser` et Édition ▸ Coller (le presse-papiers de l'éditeur) ; un collage entre crochets venu du terminal qui héberge l'éditeur, transmis entier \|
	106	+\| Sélection abandonnée par \| Une copie, un collage, un clic, un nouveau glissement \|
	107	+\| Sélection conservée malgré \| L'arrivée de sortie, le défilement, les touches envoyées au shell \|
	108	+\| Non sélectionnable \| Rien : l'écran alternatif et une fenêtre terminée peuvent tous deux être sélectionnés \|
	109	+
91	110	## Historique
92	111
93	112	\| Propriété \| Valeur \|
@@ -157,6 +176,7 @@ Activés par `CSI ? n h`, désactivés par `CSI ? n l`.
157	176	\| 47, 1047 \| \| Écran alternatif \|
158	177	\| 1048 \| \| Sauvegarder / restaurer le curseur \|
159	178	\| 1049 \| \| Sauvegarder le curseur, puis l'écran alternatif \|
	179	+\| 2004 \| \| Collage entre crochets : un collage dans la fenêtre est encadré par `ESC [ 200 ~` … `ESC [ 201 ~` \|
160	180
161	181	Tout autre mode est analysé et ignoré.
162	182
@@ -202,7 +222,7 @@ Analysées correctement, donc jamais affichées comme des caractères parasites,
202	222
203	223	### Non implémenté
204	224
205		-Le rapport souris, le collage entre crochets, les bascules shift-in / shift-out, les lignes double largeur, sixel et les autres protocoles graphiques, ainsi que les rapports d'état et d'attributs DEC. Un programme qui en demande un n'obtient aucune réponse : celui qui en attend une attendra indéfiniment.
	225	+Le rapport souris, les bascules shift-in / shift-out, les lignes double largeur, sixel et les autres protocoles graphiques, ainsi que les rapports d'état et d'attributs DEC. Un programme qui en demande un n'obtient aucune réponse : celui qui en attend une attendra indéfiniment.
206	226
207	227	## Couleurs
208	228
@@ -210,6 +230,7 @@ Le rapport souris, le collage entre crochets, les bascules shift-in / shift-out,
210	230	\| --- \| --- \|
211	231	\| `terminal.text` \| Toute cellule dont le programme n'a pas choisi la couleur \|
212	232	\| `terminal.cursor` \| La cellule sous le curseur, quand la fenêtre a le focus \|
	233	+\| `editor.selection` \| Les cellules sélectionnées — la même couleur qu'une sélection dans un fichier \|
213	234
214	235	Voir [Format des fichiers de thème](themes.md).
215	236

  ### Après la fin du programme
--Une fenêtre dont la commande est terminée garde sa sortie mais cesse de se comporter comme un terminal : seules `Maj-Page↑` et `Maj-Page↓` sont encore prises, et toute autre touche atteint l'éditeur — c'est ce qui permet à `Ctrl-W` de la fermer.
++Une fenêtre dont la commande est terminée garde sa sortie mais cesse de se comporter comme un terminal : seules les touches d'historique et de sélection — `Maj-Page↑`, `Maj-Page↓`, `Maj-↑`, `Maj-↓`, `Ctrl-Inser` et `Maj-Inser` — sont encore prises, de sorte que ce qu'elle a affiché peut encore être sélectionné et copié (rien ne peut y être collé), et toute autre touche atteint l'éditeur — c'est ce qui permet à `Ctrl-W` de la fermer.
  ### Envoyées au shell
  | --- | --- |
  | `Shift-PgUp` | Reculer d'un écran dans l'historique |
  | `Shift-PgDn` | Avancer d'un écran |
++| `Maj-↑` `Maj-↓` | Sélectionner des lignes entières : depuis la ligne du curseur du shell sans sélection, sinon une ligne de plus vers le haut ou le bas. Une sélection à la souris devient des lignes entières |
++| `Ctrl-Inser` | Copier la sélection dans le presse-papiers de l'éditeur et celui du système, puis l'abandonner. Prise même sans sélection, pour ne jamais atteindre le shell en `Insert` |
++| `Maj-Inser` | Taper le presse-papiers de l'éditeur dans le shell (voir [Copier et coller](#copier-et-coller)). Prise même si le presse-papiers est vide |
--Toute touche envoyée au shell ramène également la vue à l'écran vivant.
++Toute touche envoyée au shell ramène également la vue à l'écran vivant. `Maj-↑` et `Maj-↓` n'atteignent donc jamais un programme : celui qui les voudrait n'obtient rien.
  ## Souris
  | Action | Effet |
  | --- | --- |
  | Molette haut / bas | Défiler de trois lignes dans l'historique |
--| Clic | Passe la fenêtre au premier plan ; n'est pas transmis au programme |
++| Clic | Passe la fenêtre au premier plan et abandonne toute sélection ; n'est pas transmis au programme |
++| Glisser avec le bouton gauche | Sélectionne le texte entre le point d'appui et le pointeur, caractère par caractère d'une ligne à l'autre. Glisser au-delà du bord de la fenêtre sélectionne jusqu'à ce bord |
  Le rapport souris n'est pas implémenté : un programme n'est jamais informé des clics.
++## Copier et coller
++
++| Propriété | Valeur |
++| --- | --- |
++| Sélection | Deux cellules du texte entier — historique et écran vivant réunis —, de sorte qu'elle reste sur le même texte pendant que le shell écrit en dessous |
++| Surlignage | La clé `editor.selection` du thème, qui remplace les couleurs du programme dans la sélection |
++| Texte copié | Les cellules sélectionnées, lignes jointes par `\n`. Une ligne sélectionnée jusqu'à son bord droit perd ses blancs de fin ; une ligne sélectionnée avant le bord garde chaque blanc choisi |
++| Destination de la copie | Le presse-papiers de l'éditeur, et celui du système via OSC 52 (non vérifié : le terminal peut le refuser) |
++| Barre d'état | `Copied N lines` |
++| Texte collé | Chaque `\n` ou `\r\n` devient `\r`, comme l'envoie `Entrée`. Avec le mode privé 2004 actif, le tout est encadré par `ESC [ 200 ~` … `ESC [ 201 ~` |
++| Sources d'un collage | `Maj-Inser` et **Édition ▸ Coller** (le presse-papiers de l'éditeur) ; un collage entre crochets venu du terminal qui héberge l'éditeur, transmis entier |
++| Sélection abandonnée par | Une copie, un collage, un clic, un nouveau glissement |
++| Sélection conservée malgré | L'arrivée de sortie, le défilement, les touches envoyées au shell |
++| Non sélectionnable | Rien : l'écran alternatif et une fenêtre terminée peuvent tous deux être sélectionnés |
++
  ## Historique
  | Propriété | Valeur |
  | 47, 1047 | | Écran alternatif |
  | 1048 | | Sauvegarder / restaurer le curseur |
  | 1049 | | Sauvegarder le curseur, puis l'écran alternatif |
++| 2004 | | Collage entre crochets : un collage dans la fenêtre est encadré par `ESC [ 200 ~` … `ESC [ 201 ~` |
  Tout autre mode est analysé et ignoré.
  ### Non implémenté
--Le rapport souris, le collage entre crochets, les bascules shift-in / shift-out, les lignes double largeur, sixel et les autres protocoles graphiques, ainsi que les rapports d'état et d'attributs DEC. Un programme qui en demande un n'obtient aucune réponse : celui qui en attend une attendra indéfiniment.
++Le rapport souris, les bascules shift-in / shift-out, les lignes double largeur, sixel et les autres protocoles graphiques, ainsi que les rapports d'état et d'attributs DEC. Un programme qui en demande un n'obtient aucune réponse : celui qui en attend une attendra indéfiniment.
  ## Couleurs
  | --- | --- |
  | `terminal.text` | Toute cellule dont le programme n'a pas choisi la couleur |
  | `terminal.cursor` | La cellule sous le curseur, quand la fenêtre a le focus |
++| `editor.selection` | Les cellules sélectionnées — la même couleur qu'une sélection dans un fichier |
  Voir [Format des fichiers de thème](themes.md).

modified go.mod +1 -1 Viewed

@@ -4,7 +4,7 @@ go 1.26.1
4	4
5	5	require (
6	6	github.com/gdamore/tcell/v2 v2.13.10
7		- rickub.com/turbo-editors/turbo-core v1.0.3
	7	+ rickub.com/turbo-editors/turbo-core v1.0.4
8	8	)
9	9
10	10	require (

  require (
  	github.com/gdamore/tcell/v2 v2.13.10
--	rickub.com/turbo-editors/turbo-core v1.0.3
++	rickub.com/turbo-editors/turbo-core v1.0.4
  )
  require (

modified go.sum +2 -2 Viewed

@@ -45,5 +45,5 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn
45	45	golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
46	46	golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
47	47	golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
48		-rickub.com/turbo-editors/turbo-core v1.0.3 h1:j+bqzIIBsese8iLgre9PQdbpi9YkoOMIHP6pOli5UjE=
49		-rickub.com/turbo-editors/turbo-core v1.0.3/go.mod h1:rmfIY5gsFEo3sC5IIJFapwsGvdKG6NjrD7ACmnNTKq8=
	48	+rickub.com/turbo-editors/turbo-core v1.0.4 h1:oxySn9S6aEoHC1HPrarkxCnW5fTcPPXym7dMjSLRKaY=
	49	+rickub.com/turbo-editors/turbo-core v1.0.4/go.mod h1:rmfIY5gsFEo3sC5IIJFapwsGvdKG6NjrD7ACmnNTKq8=

  golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
  golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
  golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
--rickub.com/turbo-editors/turbo-core v1.0.3 h1:j+bqzIIBsese8iLgre9PQdbpi9YkoOMIHP6pOli5UjE=
++rickub.com/turbo-editors/turbo-core v1.0.4 h1:oxySn9S6aEoHC1HPrarkxCnW5fTcPPXym7dMjSLRKaY=
--rickub.com/turbo-editors/turbo-core v1.0.3/go.mod h1:rmfIY5gsFEo3sC5IIJFapwsGvdKG6NjrD7ACmnNTKq8=
++rickub.com/turbo-editors/turbo-core v1.0.4/go.mod h1:rmfIY5gsFEo3sC5IIJFapwsGvdKG6NjrD7ACmnNTKq8=

modified internal/gololang/snippets.toml.tmpl +1 -1 Viewed

@@ -6,7 +6,7 @@
6	6	# first is indented to match the line you inserted it on.
7	7	#
8	8	# languages restricts a snippet to files of those kinds, by the names the
9		-# editor uses: bash, dockerfile, golo, html, javascript, markdown, toml, xml,
	9	+# editor uses: bash, dockerfile, golo, html, javascript, markdown, asciidoc, toml, xml,
10	10	# yaml. Leave it out and the snippet is offered everywhere.
11	11	#
12	12	# Bodies are indented with two spaces, which is what every example in the

  # first is indented to match the line you inserted it on.
  #
  # languages restricts a snippet to files of those kinds, by the names the
--# editor uses: bash, dockerfile, golo, html, javascript, markdown, toml, xml,
++# editor uses: bash, dockerfile, golo, html, javascript, markdown, asciidoc, toml, xml,
  # yaml. Leave it out and the snippet is offered everywhere.
  #
  # Bodies are indented with two spaces, which is what every example in the

modified release.env +1 -1 Viewed

@@ -6,5 +6,5 @@
6	6	#
7	7	# ./02-build-releases.sh v1.0.0 to build the binaries by hand and see what
8	8	# the CI will publish, without publishing anything
9		-TAG="v1.0.3"
	9	+TAG="v1.0.4"
10	10	ABOUT="Turbo Golo"

  #
  #   ./02-build-releases.sh v1.0.0    to build the binaries by hand and see what
  #                                    the CI will publish, without publishing anything
--TAG="v1.0.3"
++TAG="v1.0.4"
  ABOUT="Turbo Golo"

📦 Turbo Golo