format(docs): remove escaped t's

Author: coronary

docs/bash4.md

@@ -90,7 +90,7 @@ See [read](commands/builtin/read.md)
 
 ### Changes to the "help" builtin
 
-The builtin itself didn\'t change much, but the data displayed is more
+The builtin itself didn't change much, but the data displayed is more
 structured now. The help texts are in a better format, much easier to
 read.
 

docs/commands/builtin/caller.md

@@ -60,7 +60,7 @@ f3
 ## Notes
 
 -   `caller` produces no output unless used within a script that's run
-    from a real file. It isn\'t particularly useful for interactive use,
+    from a real file. It isn't particularly useful for interactive use,
     but can be used to create a decent `die` function to track down
     errors in moderately complex scripts.
     `{ bash /dev/stdin; } <<<$'f(){ g; }\ng(){ h; }\nh(){ while caller $((n++)); do :; done; }\nf'`

docs/commands/builtin/declare.md

@@ -22,7 +22,7 @@ variable.
 When used in a function, `declare` makes `NAMEs` local variables, unless
 used with the `-g` option.
 
-Don\'t use it's synonym `typeset` when coding for Bash, since it's
+Don't use it's synonym `typeset` when coding for Bash, since it's
 tagged as obsolete.
 
 ### Options
@@ -167,7 +167,7 @@ for details. ksh93 namerefs are much more powerful than Bash's.
     possible exception of Zsh in Bash compatibility mode. Bash marks the
     synonym `typeset` as obsolete, which in Bash behaves identically to
     `declare`. All other Korn-like shells use `typeset`, so it probably
-    isn\'t going away any time soon. Unfortunately, being a non-standard
+    isn't going away any time soon. Unfortunately, being a non-standard
     builtin, `typeset` differs significantly between shells. ksh93 also
     considers `typeset` a special builtin, while Bash does not - even in
     POSIX mode. If you use `typeset`, you should attempt to only use it

docs/commands/builtin/echo.md

@@ -10,7 +10,7 @@
 newline. The return status is always `0`. If the
 [shopt](../../commands/builtin/shopt.md) option `xpg_echo` is set, Bash
 dynamically determines whether echo should expand escape characters
-(listed below) by default based on the current platform. `echo` doesn\'t
+(listed below) by default based on the current platform. `echo` doesn't
 interpret `--` as the end of options, and will simply print this string
 if given.
 

docs/commands/builtin/eval.md

@@ -33,7 +33,7 @@ the `eval` command below it.
 
 Frequently, `eval` is used to cause side-effects by performing a pass of
 expansion on the code before executing the resulting string. This allows
-for things that otherwise wouldn\'t be possible with ordinary Bash
+for things that otherwise wouldn't be possible with ordinary Bash
 syntax. This also, of course, makes `eval` the most powerful command in
 all of shell programming (and in most other languages for that matter).
 
@@ -106,7 +106,7 @@ controlled carefully by the caller is a good way to use it.
     of eval will leak out into the surrounding environment. It is
     possible to work around this limitation by prefixing special
     builtins with the `command` regular builtin, but current versions of
-    ~~ksh93~~ and zsh don\'t do this properly
+    ~~ksh93~~ and zsh don't do this properly
     ([fixed](http://article.gmane.org/gmane.comp.programming.tools.ast.devel/686)
     in ksh 93v- 2012-10-24 alpha). Earlier versions of zsh work (with
     `setopt POSIX_BUILTINS` \-- looks like a regression). This works
@@ -129,12 +129,12 @@ controlled carefully by the caller is a good way to use it.
      $ ( x=a; eval "$x"'=( a b\ c d )'; printf '<%s> ' "${a[@]}"; echo ) # Proper quoting then gives us the expected results.
     <a> <b c> <d>
 
-We don\'t know why Bash does this. Since parentheses are metacharacters,
+We don't know why Bash does this. Since parentheses are metacharacters,
 they must ordinary be quoted or escaped when used as arguments. The
 first example above is the same error as the second in all non-Bash
 shells, even those with compound assignment.
 
-In the case of `eval` it isn\'t recommended to use this behavior,
+In the case of `eval` it isn't recommended to use this behavior,
 because unlike e.g. [declare](../../commands/builtin/declare.md), the initial
 expansion is still subject to all expansions including
 [word-splitting](../../syntax/expansion/wordsplit.md) and [pathname

docs/commands/builtin/exit.md

@@ -22,7 +22,7 @@ There are no options.
 
 ### Exit status
 
-Naturally, you can\'t ask for the exit status from within the shell that
+Naturally, you can't ask for the exit status from within the shell that
 executed the `exit` command, because the shell exits.
 
   Status   Reason

docs/commands/builtin/let.md

@@ -24,7 +24,7 @@ difference being `let` is a builtin (simple command), and `((` is a
 compound command. The arguments to `let` are therefore subject to all
 the same expansions and substitutions as any other simple command -
 requiring proper quoting and escaping - whereas the contents of `((`
-aren\'t subject to [word-splitting](../../syntax/expansion/wordsplit.md) or
+aren't subject to [word-splitting](../../syntax/expansion/wordsplit.md) or
 [pathname expansion](../../syntax/expansion/globs.md) (almost never desirable
 for arithmetic). For this reason, **the [arithmetic compound
 command](../../syntax/ccmd/arithmetic_eval.md) should generally be preferred
@@ -80,7 +80,7 @@ needed.
 -   It seems to be a common misunderstanding that `let` has some legacy
     purpose. Both `let` and [[^1]](../../syntax/ccmd/arithmetic_eval.md) were
     ksh88 features and almost identical in terms of portability as
-    everything that inherited one also tended to get the other. Don\'t
+    everything that inherited one also tended to get the other. Don't
     choose `let` over `((` expecting it to work in more places.
 -   [expr(1)](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/expr.html#tag_20_42)
     is a command one is likely to come across sooner or later. While it

docs/commands/builtin/local.md

@@ -26,7 +26,7 @@ way, and takes all the same options, with 3 exceptions:
 
 ## Portability considerations
 
--   `local` is not specified by POSIX. Most bourne-like shells don\'t
+-   `local` is not specified by POSIX. Most bourne-like shells don't
     have a builtin called `local`, but some such as `dash` and the
     busybox shell do.
 
@@ -41,15 +41,15 @@ way, and takes all the same options, with 3 exceptions:
 ```{=html}
 <!-- -->
 ```
--   In ksh93, using POSIX-style function definitions, `typeset` doesn\'t
+-   In ksh93, using POSIX-style function definitions, `typeset` doesn't
     set `local` variables, but rather acts upon variables of the
     next-outermost scope (e.g. setting attributes). Using `typeset`
     within functions defined using ksh `function name {` syntax,
     variables follow roughly
     [lexical-scoping](http://community.schemewiki.org/?lexical-scope),
-    except that functions themselves don\'t have scope, just like Bash.
+    except that functions themselves don't have scope, just like Bash.
     This means that even functions defined within a \"function's
-    scope\" don\'t have access to non-local variables except through
+    scope\" don't have access to non-local variables except through
     `namerefs`.
 
 ## See also

docs/commands/builtin/mapfile.md

@@ -29,13 +29,13 @@ given array `ARRAY` is set readonly.
   `-t`            Remove any trailing newline from a line read, before it is assigned to an array element.
   `-u FD`         Read from filedescriptor `FD` rather than standard input.
 
-While `mapfile` isn\'t a common or portable shell feature, it's
+While `mapfile` isn't a common or portable shell feature, it's
 functionality will be familiar to many programmers. Almost all
 programming languages (aside from shells) with support for compound
 datatypes like arrays, and which handle open file objects in the
 traditional way, have some analogous shortcut for easily reading all
 lines of some input as a standard feature. In Bash, `mapfile` in itself
-can\'t do anything that couldn\'t already be done using read and a loop,
+can't do anything that couldn't already be done using read and a loop,
 and if portability is even a slight concern, should never be used.
 However, it does *significantly* outperform a read loop, and can make
 for shorter and cleaner code - especially convenient for interactive
@@ -62,7 +62,7 @@ Note the use of command grouping to keep the emerge command inside the
 pipe's subshell and within the scope of \"args\". Also note the unusual
 redirection. This is because the -a flag makes emerge interactive,
 asking the user for confirmation before continuing, and checking with
-isatty(3) to abort if stdin isn\'t pointed at a terminal. Since stdin of
+isatty(3) to abort if stdin isn't pointed at a terminal. Since stdin of
 the entire command group is still coming from the pipe even though
 mapfile has read all available input, we just borrow FD 1 as it just so
 happens to be pointing where we want it. More on this over at greycat's
@@ -216,6 +216,6 @@ each subsequent 2 iterations. The RETURN trap is unimportant.
 ## See also
 
 -   [arrays](../../syntax/arrays.md)
--   [read](../../commands/builtin/read.md) - If you don\'t know about this yet,
+-   [read](../../commands/builtin/read.md) - If you don't know about this yet,
     why are you reading this page?
 -   <http://mywiki.wooledge.org/BashFAQ/001> - It's FAQ 1 for a reason.

docs/commands/builtin/printf.md

@@ -12,7 +12,7 @@ expects a comma after the format string and between each of the
 arguments of a **printf** command. For examples, see: [code
 snippet](../../printf?&.md#using_printf_inside_of_awk). \</div\>
 
-Unlike other documentations, I don\'t want to redirect you to the manual
+Unlike other documentations, I don't want to redirect you to the manual
 page for the `printf()` C function family. However, if you\'re more
 experienced, that should be the most detailed description for the format
 strings and modifiers.
@@ -54,7 +54,7 @@ argument!).
   `-v VAR`   If given, the output is assigned to the variable `VAR` instead of printed to `stdout` (comparable to `sprintf()` in some way)
   ---------- -------------------------------------------------------------------------------------------------------------------------------
 
-The `-v` Option can\'t assign directly to array indexes in Bash versions
+The `-v` Option can't assign directly to array indexes in Bash versions
 older than Bash 4.1.
 
 \<note warning\> In versions newer than 4.1, one must be careful when
@@ -84,8 +84,8 @@ recognized to give a number-argument to `printf`:
   `0N`            An octal number
   `0xN`           A hexadecimal number
   `0XN`           A hexadecimal number
-  `"X`            (a literal double-quote infront of a character): interpreted as number (underlying codeset) **don\'t forget escaping**
-  `'X`            (a literal single-quote infront of a character): interpreted as number (underlying codeset) **don\'t forget escaping**
+  `"X`            (a literal double-quote infront of a character): interpreted as number (underlying codeset) **don't forget escaping**
+  `'X`            (a literal single-quote infront of a character): interpreted as number (underlying codeset) **don't forget escaping**
 
 [**If more arguments than format specifiers**]{.underline} are present,
 then the format string is re-used until the last argument is
@@ -143,7 +143,7 @@ all mean the same: A placeholder for data with a specified format:
   `%G`           Same as `%g`, but print it like `%E`
   `%c`           Interprets the associated argument as **char**: only the first character of a given argument is printed
   `%s`           Interprets the associated argument literally as string
-  `%n`           Assigns the number of characters printed so far to the variable named in the corresponding argument. Can\'t specify an array index. If the given name is already an array, the value is assigned to the zeroth element.
+  `%n`           Assigns the number of characters printed so far to the variable named in the corresponding argument. Can't specify an array index. If the given name is already an array, the value is assigned to the zeroth element.
   `%a`           Interprets the associated argument as **double**, and prints it in the form of a C99 [hexadecimal floating-point literal](http://www.exploringbinary.com/hexadecimal-floating-point-constants/).
   `%A`           Same as `%a`, but print it like `%E`
   `%(FORMAT)T`   output the date-time string resulting from using `FORMAT` as a format string for `strftime(3)`. The associated argument is the number of seconds since Epoch, or `-1` (current time) or `-2` (shell startup time). If no corresponding argument is supplies, the current time is used as default
@@ -192,7 +192,7 @@ that precedes the number to print, like (prints 4,3000000000):
 
     printf "%.*f\n" 10 4,3
 
-The format `.*N` to specify the N\'th argument for precision does not
+The format `.*N` to specify the N'th argument for precision does not
 work in Bash.
 
 For strings, the precision specifies the maximum number of characters to
@@ -364,7 +364,7 @@ correct awk syntax.
 
 With appropriate metacharacter escaping the bash printf can be called
 from inside awk (as from perl and other languages that support shell
-callout) as long as you don\'t care about program efficiency or
+callout) as long as you don't care about program efficiency or
 readability.
 
     echo "Foo" | awk '{ system( "printf \"%s\\n \" \"" $1 "\""  ) }'
@@ -453,7 +453,7 @@ fmt++;
     synopsis as:
     `print: print [-Rnprs] [-u unit] [-f format] [arguments]`. However,
     only `-Rrnfu` are actually functional. Internally, `-p` is a noop
-    (it doesn\'t tie in with Bash coprocs at all), and `-s` only sets a
+    (it doesn't tie in with Bash coprocs at all), and `-s` only sets a
     flag but has no effect. `-Cev` are unimplemented.
 
 ```{=html}