diff --git a/doc/snapraid-de.1 b/doc/snapraid-de.1
index f0053f67..d24f8b4c 100644
--- a/doc/snapraid-de.1
+++ b/doc/snapraid-de.1
@@ -2091,18 +2091,19 @@ Schrägstrich, was ihn für den Abgleich innerhalb einer einzelnen Pfadkomponent
 geeignet macht. Dies ist das Standardverhalten von Wildcards, das vom Shell\-
 Globbing bekannt ist.
 .PP
-Der Doppelstern \`**\` ist mächtiger; er entspricht jeder Folge von
-Zeichen einschließlich Verzeichnistrennzeichen. Dies ermöglicht es Mustern, über
-mehrere Verzeichnisebenen hinweg übereinzustimmen. Wenn \`**\` direkt in
-ein Muster eingebettet ist, kann es null oder mehr Zeichen einschließlich Schrägstrichen zwischen
-dem umgebenden wörtlichen Text entsprechen.
+Der Doppelstern\-Platzhalter \`**\` entspricht nur dann über Verzeichnistrennzeichen
+hinweg, wenn er an ein Verzeichnistrennzeichen angrenzt (einem Schrägstrich
+vorangestellt oder nachgestellt). In dieser Form entspricht er null oder mehr
+Zeichen über Verzeichnisebenen hinweg. Zum Beispiel entspricht \`foo/**/bar\` den
+Pfaden \`foo/bar\`, \`foo/a/bar\` und \`foo/a/b/bar\`; \`**/build\` entspricht \`build\`
+und \`foo/bar/build\`; und \`src/**.js\` entspricht \`src/main.js\` und
+\`src/ui/components/main.js\`.
+Die alleinstehende Form \`/**/\` wird nicht als vollständiges Muster akzeptiert.
 .PP
-Die wichtigste Verwendung von \`**\` ist in der speziellen Form \`/**/\`. Dies entspricht
-null oder mehr vollständigen Verzeichnisebenen, was es möglich macht, Dateien
-in jeder Tiefe eines Verzeichnisbaums abzugleichen, ohne die genaue Pfadstruktur zu kennen.
-Zum Beispiel entspricht das Muster \`src/**/main.js\` dem Pfad \`src/main.js\` (Überspringen
-von null Verzeichnissen), \`src/ui/main.js\` (Überspringen eines Verzeichnisses) und
-\`src/ui/components/main.js\` (Überspringen von zwei Verzeichnissen).
+Wenn \`**\` nicht an einen Schrägstrich angrenzt, verhält er sich wie \`*\` und
+entspricht keinen Verzeichnistrennzeichen. Zum Beispiel entspricht \`**.jpg\`
+der Datei \`photo.jpg\` im aktuellen Verzeichnis, nicht jedoch \`dir/photo.jpg\`.
+Verwenden Sie für diesen Zweck \`**/*.jpg\`.
 .PP
 Zeichenklassen mit eckigen Klammern \`[]\` entsprechen einem einzelnen Zeichen aus einer
 bestimmten Menge oder einem Bereich. Wie die anderen Einzelzeichenmuster
@@ -2111,8 +2112,8 @@ ein Ausrufezeichen.
 .PP
 Der grundlegende Unterschied, den man sich merken sollte, ist, dass \`*\`, \`?\` und Zeichenklassen
 alle Verzeichnisgrenzen respektieren und nur innerhalb einer einzelnen Pfadkomponente
-übereinstimmen, während \`**\` das einzige Muster ist, das über Verzeichnistrennzeichen
-hinweg übereinstimmen kann.
+übereinstimmen, während \`**\` nur dann über Verzeichnistrennzeichen hinweg übereinstimmen kann,
+wenn es an einen Schrägstrich angrenzt.
 .PP
 Es gibt vier verschiedene Arten von Mustern:
 .TP
diff --git a/doc/snapraid-de.d b/doc/snapraid-de.d
index 35188b39..94101262 100644
--- a/doc/snapraid-de.d
+++ b/doc/snapraid-de.d
@@ -1685,18 +1685,19 @@ Muster (Pattern)
 	geeignet macht. Dies ist das Standardverhalten von Wildcards, das vom Shell-
 	Globbing bekannt ist.
 
-	Der Doppelstern `**` ist mächtiger; er entspricht jeder Folge von
-	Zeichen einschließlich Verzeichnistrennzeichen. Dies ermöglicht es Mustern, über
-	mehrere Verzeichnisebenen hinweg übereinzustimmen. Wenn `**` direkt in
-	ein Muster eingebettet ist, kann es null oder mehr Zeichen einschließlich Schrägstrichen zwischen
-	dem umgebenden wörtlichen Text entsprechen.
+	Der Doppelstern-Platzhalter `**` entspricht nur dann über Verzeichnistrennzeichen
+	hinweg, wenn er an ein Verzeichnistrennzeichen angrenzt (einem Schrägstrich
+	vorangestellt oder nachgestellt). In dieser Form entspricht er null oder mehr
+	Zeichen über Verzeichnisebenen hinweg. Zum Beispiel entspricht `foo/**/bar` den
+	Pfaden `foo/bar`, `foo/a/bar` und `foo/a/b/bar`; `**/build` entspricht `build`
+	und `foo/bar/build`; und `src/**.js` entspricht `src/main.js` und
+	`src/ui/components/main.js`.
+	Die alleinstehende Form `/**/` wird nicht als vollständiges Muster akzeptiert.
 
-	Die wichtigste Verwendung von `**` ist in der speziellen Form `/**/`. Dies entspricht
-	null oder mehr vollständigen Verzeichnisebenen, was es möglich macht, Dateien
-	in jeder Tiefe eines Verzeichnisbaums abzugleichen, ohne die genaue Pfadstruktur zu kennen.
-	Zum Beispiel entspricht das Muster `src/**/main.js` dem Pfad `src/main.js` (Überspringen
-	von null Verzeichnissen), `src/ui/main.js` (Überspringen eines Verzeichnisses) und
-	`src/ui/components/main.js` (Überspringen von zwei Verzeichnissen).
+	Wenn `**` nicht an einen Schrägstrich angrenzt, verhält er sich wie `*` und
+	entspricht keinen Verzeichnistrennzeichen. Zum Beispiel entspricht `**.jpg`
+	der Datei `photo.jpg` im aktuellen Verzeichnis, nicht jedoch `dir/photo.jpg`.
+	Verwenden Sie für diesen Zweck `**/*.jpg`.
 
 	Zeichenklassen mit eckigen Klammern `[]` entsprechen einem einzelnen Zeichen aus einer
 	bestimmten Menge oder einem Bereich. Wie die anderen Einzelzeichenmuster
@@ -1705,8 +1706,8 @@ Muster (Pattern)
 
 	Der grundlegende Unterschied, den man sich merken sollte, ist, dass `*`, `?` und Zeichenklassen
 	alle Verzeichnisgrenzen respektieren und nur innerhalb einer einzelnen Pfadkomponente
-	übereinstimmen, während `**` das einzige Muster ist, das über Verzeichnistrennzeichen
-	hinweg übereinstimmen kann.
+	übereinstimmen, während `**` nur dann über Verzeichnistrennzeichen hinweg übereinstimmen kann,
+	wenn es an einen Schrägstrich angrenzt.
 
 	Es gibt vier verschiedene Arten von Mustern:
 
diff --git a/doc/snapraid-de.txt b/doc/snapraid-de.txt
index e3e7a785..1d63aa41 100644
--- a/doc/snapraid-de.txt
+++ b/doc/snapraid-de.txt
@@ -1798,18 +1798,19 @@ Schrägstrich, was ihn für den Abgleich innerhalb einer einzelnen Pfadkomponent
 geeignet macht. Dies ist das Standardverhalten von Wildcards, das vom Shell-
 Globbing bekannt ist.
 
-Der Doppelstern `**` ist mächtiger; er entspricht jeder Folge von
-Zeichen einschließlich Verzeichnistrennzeichen. Dies ermöglicht es Mustern, über
-mehrere Verzeichnisebenen hinweg übereinzustimmen. Wenn `**` direkt in
-ein Muster eingebettet ist, kann es null oder mehr Zeichen einschließlich Schrägstrichen zwischen
-dem umgebenden wörtlichen Text entsprechen.
+Der Doppelstern-Platzhalter `**` entspricht nur dann über Verzeichnistrennzeichen
+hinweg, wenn er an ein Verzeichnistrennzeichen angrenzt (einem Schrägstrich
+vorangestellt oder nachgestellt). In dieser Form entspricht er null oder mehr
+Zeichen über Verzeichnisebenen hinweg. Zum Beispiel entspricht `foo/**/bar` den
+Pfaden `foo/bar`, `foo/a/bar` und `foo/a/b/bar`; `**/build` entspricht `build`
+und `foo/bar/build`; und `src/**.js` entspricht `src/main.js` und
+`src/ui/components/main.js`.
+Die alleinstehende Form `/**/` wird nicht als vollständiges Muster akzeptiert.
 
-Die wichtigste Verwendung von `**` ist in der speziellen Form `/**/`. Dies entspricht
-null oder mehr vollständigen Verzeichnisebenen, was es möglich macht, Dateien
-in jeder Tiefe eines Verzeichnisbaums abzugleichen, ohne die genaue Pfadstruktur zu kennen.
-Zum Beispiel entspricht das Muster `src/**/main.js` dem Pfad `src/main.js` (Überspringen
-von null Verzeichnissen), `src/ui/main.js` (Überspringen eines Verzeichnisses) und
-`src/ui/components/main.js` (Überspringen von zwei Verzeichnissen).
+Wenn `**` nicht an einen Schrägstrich angrenzt, verhält er sich wie `*` und
+entspricht keinen Verzeichnistrennzeichen. Zum Beispiel entspricht `**.jpg`
+der Datei `photo.jpg` im aktuellen Verzeichnis, nicht jedoch `dir/photo.jpg`.
+Verwenden Sie für diesen Zweck `**/*.jpg`.
 
 Zeichenklassen mit eckigen Klammern `[]` entsprechen einem einzelnen Zeichen aus einer
 bestimmten Menge oder einem Bereich. Wie die anderen Einzelzeichenmuster
@@ -1818,8 +1819,8 @@ ein Ausrufezeichen.
 
 Der grundlegende Unterschied, den man sich merken sollte, ist, dass `*`, `?` und Zeichenklassen
 alle Verzeichnisgrenzen respektieren und nur innerhalb einer einzelnen Pfadkomponente
-übereinstimmen, während `**` das einzige Muster ist, das über Verzeichnistrennzeichen
-hinweg übereinstimmen kann.
+übereinstimmen, während `**` nur dann über Verzeichnistrennzeichen hinweg übereinstimmen kann,
+wenn es an einen Schrägstrich angrenzt.
 
 Es gibt vier verschiedene Arten von Mustern:
 
diff --git a/doc/snapraid-es.1 b/doc/snapraid-es.1
index a60db17f..494e056d 100644
--- a/doc/snapraid-es.1
+++ b/doc/snapraid-es.1
@@ -2050,18 +2050,19 @@ barra diagonal, lo que lo hace adecuado para buscar coincidencias dentro de un s
 componente de ruta. Este es el comportamiento estándar de los comodines familiar
 del globbing de la shell.
 .PP
-el doble asterisco \`**\` es más potente, coincide con cualquier secuencia de
-caracteres, incluidos los separadores de directorios. Esto permite que los patrones coincidan
-a través de múltiples niveles de directorio. Cuando \`**\` aparece incrustado directamente en
-un patrón, puede coincidir con cero o más caracteres, incluidas las barras diagonales entre
-el texto literal circundante.
+El comodín de doble asterisco \`**\` coincide a través de los separadores de
+directorios solo cuando es adyacente a un separador de directorios (precedido
+o seguido por una barra diagonal). En esta forma, coincide con cero o más
+caracteres a través de niveles de directorio. Por ejemplo, \`foo/**/bar\`
+coincide con \`foo/bar\`, \`foo/a/bar\` y \`foo/a/b/bar\`; \`**/build\` coincide con
+\`build\` y \`foo/bar/build\`; y \`src/**.js\` coincide con \`src/main.js\` y
+\`src/ui/components/main.js\`.
+La forma independiente \`/**/\` no se acepta como un patrón completo.
 .PP
-El uso más importante de \`**\` es en la forma especial \`/**/\`. Esta coincide con
-cero o más niveles de directorio completos, lo que permite que los archivos coincidan
-a cualquier profundidad en un árbol de directorios sin conocer la estructura exacta de la ruta.
-Por ejemplo, el patrón \`src/**/main.js\` coincide con \`src/main.js\` (saltando
-cero directorios), \`src/ui/main.js\` (saltando un directorio) y
-\`src/ui/components/main.js\` (saltando dos directorios).
+Cuando \`**\` no es adyacente a una barra diagonal, se comporta como \`*\` y no
+coincide con los separadores de directorios. Por ejemplo, \`**.jpg\` coincide
+con \`photo.jpg\` en el directorio actual, pero no coincide con \`dir/photo.jpg\`.
+Use \`**/*.jpg\` para ese propósito.
 .PP
 Las clases de caracteres que utilizan corchetes \`[]\` coinciden con un solo carácter de un
 conjunto o rango especificado. Al igual que los otros patrones de un solo carácter,
@@ -2070,8 +2071,8 @@ un signo de exclamación.
 .PP
 La distinción fundamental que debe recordar es que \`*\`, \`?\` y las clases de caracteres
 respetan los límites de los directorios y solo coinciden dentro de un único
-componente de ruta, mientras que \`**\` es el único patrón que puede coincidir a través de
-los separadores de directorios.
+componente de ruta, mientras que \`**\` solo puede coincidir a través de los separadores
+de directorios cuando es adyacente a una barra diagonal.
 .PP
 Hay cuatro tipos diferentes de patrones:
 .TP
diff --git a/doc/snapraid-es.d b/doc/snapraid-es.d
index d89a9b0c..5b34036e 100644
--- a/doc/snapraid-es.d
+++ b/doc/snapraid-es.d
@@ -1655,18 +1655,19 @@ Patrones (Pattern)
 	componente de ruta. Este es el comportamiento estándar de los comodines familiar
 	del globbing de la shell.
 
-	el doble asterisco `**` es más potente, coincide con cualquier secuencia de
-	caracteres, incluidos los separadores de directorios. Esto permite que los patrones coincidan
-	a través de múltiples niveles de directorio. Cuando `**` aparece incrustado directamente en
-	un patrón, puede coincidir con cero o más caracteres, incluidas las barras diagonales entre
-	el texto literal circundante.
+	El comodín de doble asterisco `**` coincide a través de los separadores de
+	directorios solo cuando es adyacente a un separador de directorios (precedido
+	o seguido por una barra diagonal). En esta forma, coincide con cero o más
+	caracteres a través de niveles de directorio. Por ejemplo, `foo/**/bar`
+	coincide con `foo/bar`, `foo/a/bar` y `foo/a/b/bar`; `**/build` coincide con
+	`build` y `foo/bar/build`; y `src/**.js` coincide con `src/main.js` y
+	`src/ui/components/main.js`.
+	La forma independiente `/**/` no se acepta como un patrón completo.
 
-	El uso más importante de `**` es en la forma especial `/**/`. Esta coincide con
-	cero o más niveles de directorio completos, lo que permite que los archivos coincidan
-	a cualquier profundidad en un árbol de directorios sin conocer la estructura exacta de la ruta.
-	Por ejemplo, el patrón `src/**/main.js` coincide con `src/main.js` (saltando
-	cero directorios), `src/ui/main.js` (saltando un directorio) y
-	`src/ui/components/main.js` (saltando dos directorios).
+	Cuando `**` no es adyacente a una barra diagonal, se comporta como `*` y no
+	coincide con los separadores de directorios. Por ejemplo, `**.jpg` coincide
+	con `photo.jpg` en el directorio actual, pero no coincide con `dir/photo.jpg`.
+	Use `**/*.jpg` para ese propósito.
 
 	Las clases de caracteres que utilizan corchetes `[]` coinciden con un solo carácter de un
 	conjunto o rango especificado. Al igual que los otros patrones de un solo carácter,
@@ -1675,8 +1676,8 @@ Patrones (Pattern)
 
 	La distinción fundamental que debe recordar es que `*`, `?` y las clases de caracteres
 	respetan los límites de los directorios y solo coinciden dentro de un único
-	componente de ruta, mientras que `**` es el único patrón que puede coincidir a través de
-	los separadores de directorios.
+	componente de ruta, mientras que `**` solo puede coincidir a través de los separadores
+	de directorios cuando es adyacente a una barra diagonal.
 
 	Hay cuatro tipos diferentes de patrones:
 
diff --git a/doc/snapraid-es.txt b/doc/snapraid-es.txt
index 8fdeaf51..3f99d9ff 100644
--- a/doc/snapraid-es.txt
+++ b/doc/snapraid-es.txt
@@ -1768,18 +1768,19 @@ barra diagonal, lo que lo hace adecuado para buscar coincidencias dentro de un s
 componente de ruta. Este es el comportamiento estándar de los comodines familiar
 del globbing de la shell.
 
-el doble asterisco `**` es más potente, coincide con cualquier secuencia de
-caracteres, incluidos los separadores de directorios. Esto permite que los patrones coincidan
-a través de múltiples niveles de directorio. Cuando `**` aparece incrustado directamente en
-un patrón, puede coincidir con cero o más caracteres, incluidas las barras diagonales entre
-el texto literal circundante.
+El comodín de doble asterisco `**` coincide a través de los separadores de
+directorios solo cuando es adyacente a un separador de directorios (precedido
+o seguido por una barra diagonal). En esta forma, coincide con cero o más
+caracteres a través de niveles de directorio. Por ejemplo, `foo/**/bar`
+coincide con `foo/bar`, `foo/a/bar` y `foo/a/b/bar`; `**/build` coincide con
+`build` y `foo/bar/build`; y `src/**.js` coincide con `src/main.js` y
+`src/ui/components/main.js`.
+La forma independiente `/**/` no se acepta como un patrón completo.
 
-El uso más importante de `**` es en la forma especial `/**/`. Esta coincide con
-cero o más niveles de directorio completos, lo que permite que los archivos coincidan
-a cualquier profundidad en un árbol de directorios sin conocer la estructura exacta de la ruta.
-Por ejemplo, el patrón `src/**/main.js` coincide con `src/main.js` (saltando
-cero directorios), `src/ui/main.js` (saltando un directorio) y
-`src/ui/components/main.js` (saltando dos directorios).
+Cuando `**` no es adyacente a una barra diagonal, se comporta como `*` y no
+coincide con los separadores de directorios. Por ejemplo, `**.jpg` coincide
+con `photo.jpg` en el directorio actual, pero no coincide con `dir/photo.jpg`.
+Use `**/*.jpg` para ese propósito.
 
 Las clases de caracteres que utilizan corchetes `[]` coinciden con un solo carácter de un
 conjunto o rango especificado. Al igual que los otros patrones de un solo carácter,
@@ -1788,8 +1789,8 @@ un signo de exclamación.
 
 La distinción fundamental que debe recordar es que `*`, `?` y las clases de caracteres
 respetan los límites de los directorios y solo coinciden dentro de un único
-componente de ruta, mientras que `**` es el único patrón que puede coincidir a través de
-los separadores de directorios.
+componente de ruta, mientras que `**` solo puede coincidir a través de los separadores
+de directorios cuando es adyacente a una barra diagonal.
 
 Hay cuatro tipos diferentes de patrones:
 
diff --git a/doc/snapraid-fr.1 b/doc/snapraid-fr.1
index 98f6ca06..5165094d 100644
--- a/doc/snapraid-fr.1
+++ b/doc/snapraid-fr.1
@@ -2088,18 +2088,19 @@ barre oblique, ce qui la rend adaptée à la recherche de correspondances au sei
 composant de chemin. Il s\'agit du comportement standard des jokers familier du
 \[dq]globbing\[dq] shell.
 .PP
-La double étoile \`**\` est plus puissante, elle correspond à n\'importe quelle séquence de
-caractères, y compris les séparateurs de répertoires. Cela permet aux motifs de correspondre
-sur plusieurs niveaux de répertoires. Lorsque \`**\` apparaît directement intégré dans
-un motif, il peut correspondre à zéro ou plusieurs caractères, y compris les barres obliques entre
-le texte littéral environnant.
+Le caractère générique double étoile \`**\` ne correspond à travers les
+séparateurs de répertoires que lorsqu\'il est adjacent à un séparateur de
+répertoires (précédé ou suivi d\'une barre oblique). Sous cette forme, il
+correspond à zéro ou plusieurs caractères sur plusieurs niveaux de
+répertoires. Par exemple, \`foo/**/bar\` correspond à \`foo/bar\`, \`foo/a/bar\`
+et \`foo/a/b/bar\` ; \`**/build\` correspond à \`build\` et \`foo/bar/build\` ; et
+\`src/**.js\` correspond à \`src/main.js\` et \`src/ui/components/main.js\`.
+La forme autonome \`/**/\` n\'est pas acceptée comme un motif complet.
 .PP
-L\'utilisation la plus importante de \`**\` est sous la forme spéciale \`/**/\`. Celle\-ci correspond à
-zéro ou plusieurs niveaux de répertoires complets, ce qui permet de faire correspondre des fichiers
-à n\'importe quelle profondeur dans une arborescence de répertoires sans connaître la structure exacte du chemin.
-Par exemple, le motif \`src/**/main.js\` correspond à \`src/main.js\` (saut de
-zéro répertoire), \`src/ui/main.js\` (saut d\'un répertoire), et
-\`src/ui/components/main.js\` (saut de deux répertoires).
+Lorsque \`**\` n\'est pas adjacent à une barre oblique, il se comporte comme \`*\`
+et ne correspond pas aux séparateurs de répertoires. Par exemple, \`**.jpg\`
+correspond à \`photo.jpg\` dans le répertoire actuel, mais ne correspond pas à
+\`dir/photo.jpg\`. Utilisez \`**/*.jpg\` à cette fin.
 .PP
 Les classes de caractères utilisant des crochets \`[]\` correspondent à un seul caractère d\'un
 ensemble ou d\'une plage spécifiés. Comme les autres motifs à caractère unique, elles
@@ -2108,8 +2109,8 @@ d\'un point d\'exclamation.
 .PP
 La distinction fondamentale à retenir est que \`*\`, \`?\` et les classes de caractères
 respectent tous les limites des répertoires et ne correspondent qu\'au sein d\'un seul
-composant de chemin, alors que \`**\` est le seul motif qui peut correspondre à travers
-les séparateurs de répertoires.
+composant de chemin, alors que \`**\` ne peut correspondre à travers les séparateurs
+de répertoires que lorsqu\'il est adjacent à une barre oblique.
 .PP
 Il existe quatre types de motifs différents :
 .TP
diff --git a/doc/snapraid-fr.d b/doc/snapraid-fr.d
index 92f536a8..b248c696 100644
--- a/doc/snapraid-fr.d
+++ b/doc/snapraid-fr.d
@@ -1693,18 +1693,19 @@ Motif (Pattern)
 	composant de chemin. Il s'agit du comportement standard des jokers familier du
 	"globbing" shell.
 
-	La double étoile `**` est plus puissante, elle correspond à n'importe quelle séquence de
-	caractères, y compris les séparateurs de répertoires. Cela permet aux motifs de correspondre
-	sur plusieurs niveaux de répertoires. Lorsque `**` apparaît directement intégré dans
-	un motif, il peut correspondre à zéro ou plusieurs caractères, y compris les barres obliques entre
-	le texte littéral environnant.
+	Le caractère générique double étoile `**` ne correspond à travers les
+	séparateurs de répertoires que lorsqu'il est adjacent à un séparateur de
+	répertoires (précédé ou suivi d'une barre oblique). Sous cette forme, il
+	correspond à zéro ou plusieurs caractères sur plusieurs niveaux de
+	répertoires. Par exemple, `foo/**/bar` correspond à `foo/bar`, `foo/a/bar`
+	et `foo/a/b/bar` ; `**/build` correspond à `build` et `foo/bar/build` ; et
+	`src/**.js` correspond à `src/main.js` et `src/ui/components/main.js`.
+	La forme autonome `/**/` n'est pas acceptée comme un motif complet.
 
-	L'utilisation la plus importante de `**` est sous la forme spéciale `/**/`. Celle-ci correspond à
-	zéro ou plusieurs niveaux de répertoires complets, ce qui permet de faire correspondre des fichiers
-	à n'importe quelle profondeur dans une arborescence de répertoires sans connaître la structure exacte du chemin.
-	Par exemple, le motif `src/**/main.js` correspond à `src/main.js` (saut de
-	zéro répertoire), `src/ui/main.js` (saut d'un répertoire), et
-	`src/ui/components/main.js` (saut de deux répertoires).
+	Lorsque `**` n'est pas adjacent à une barre oblique, il se comporte comme `*`
+	et ne correspond pas aux séparateurs de répertoires. Par exemple, `**.jpg`
+	correspond à `photo.jpg` dans le répertoire actuel, mais ne correspond pas à
+	`dir/photo.jpg`. Utilisez `**/*.jpg` à cette fin.
 
 	Les classes de caractères utilisant des crochets `[]` correspondent à un seul caractère d'un
 	ensemble ou d'une plage spécifiés. Comme les autres motifs à caractère unique, elles
@@ -1713,8 +1714,8 @@ Motif (Pattern)
 
 	La distinction fondamentale à retenir est que `*`, `?` et les classes de caractères
 	respectent tous les limites des répertoires et ne correspondent qu'au sein d'un seul
-	composant de chemin, alors que `**` est le seul motif qui peut correspondre à travers
-	les séparateurs de répertoires.
+	composant de chemin, alors que `**` ne peut correspondre à travers les séparateurs
+	de répertoires que lorsqu'il est adjacent à une barre oblique.
 
 	Il existe quatre types de motifs différents :
 
diff --git a/doc/snapraid-fr.txt b/doc/snapraid-fr.txt
index 7525b773..cfa1ea45 100644
--- a/doc/snapraid-fr.txt
+++ b/doc/snapraid-fr.txt
@@ -1806,18 +1806,19 @@ barre oblique, ce qui la rend adaptée à la recherche de correspondances au sei
 composant de chemin. Il s'agit du comportement standard des jokers familier du
 "globbing" shell.
 
-La double étoile `**` est plus puissante, elle correspond à n'importe quelle séquence de
-caractères, y compris les séparateurs de répertoires. Cela permet aux motifs de correspondre
-sur plusieurs niveaux de répertoires. Lorsque `**` apparaît directement intégré dans
-un motif, il peut correspondre à zéro ou plusieurs caractères, y compris les barres obliques entre
-le texte littéral environnant.
+Le caractère générique double étoile `**` ne correspond à travers les
+séparateurs de répertoires que lorsqu'il est adjacent à un séparateur de
+répertoires (précédé ou suivi d'une barre oblique). Sous cette forme, il
+correspond à zéro ou plusieurs caractères sur plusieurs niveaux de
+répertoires. Par exemple, `foo/**/bar` correspond à `foo/bar`, `foo/a/bar`
+et `foo/a/b/bar` ; `**/build` correspond à `build` et `foo/bar/build` ; et
+`src/**.js` correspond à `src/main.js` et `src/ui/components/main.js`.
+La forme autonome `/**/` n'est pas acceptée comme un motif complet.
 
-L'utilisation la plus importante de `**` est sous la forme spéciale `/**/`. Celle-ci correspond à
-zéro ou plusieurs niveaux de répertoires complets, ce qui permet de faire correspondre des fichiers
-à n'importe quelle profondeur dans une arborescence de répertoires sans connaître la structure exacte du chemin.
-Par exemple, le motif `src/**/main.js` correspond à `src/main.js` (saut de
-zéro répertoire), `src/ui/main.js` (saut d'un répertoire), et
-`src/ui/components/main.js` (saut de deux répertoires).
+Lorsque `**` n'est pas adjacent à une barre oblique, il se comporte comme `*`
+et ne correspond pas aux séparateurs de répertoires. Par exemple, `**.jpg`
+correspond à `photo.jpg` dans le répertoire actuel, mais ne correspond pas à
+`dir/photo.jpg`. Utilisez `**/*.jpg` à cette fin.
 
 Les classes de caractères utilisant des crochets `[]` correspondent à un seul caractère d'un
 ensemble ou d'une plage spécifiés. Comme les autres motifs à caractère unique, elles
@@ -1826,8 +1827,8 @@ d'un point d'exclamation.
 
 La distinction fondamentale à retenir est que `*`, `?` et les classes de caractères
 respectent tous les limites des répertoires et ne correspondent qu'au sein d'un seul
-composant de chemin, alors que `**` est le seul motif qui peut correspondre à travers
-les séparateurs de répertoires.
+composant de chemin, alors que `**` ne peut correspondre à travers les séparateurs
+de répertoires que lorsqu'il est adjacent à une barre oblique.
 
 Il existe quatre types de motifs différents :
 
diff --git a/doc/snapraid-it.1 b/doc/snapraid-it.1
index 70c7e187..b714d85b 100644
--- a/doc/snapraid-it.1
+++ b/doc/snapraid-it.1
@@ -2072,18 +2072,19 @@ slash in avanti, rendendolo adatto per la corrispondenza all\'interno di un sing
 componente del percorso. Questo è il comportamento standard dei wildcard familiare
 dal globbing della shell.
 .PP
-Il doppio asterisco \`**\` è più potente, corrisponde a qualsiasi sequenza di
-caratteri inclusi i separatori di directory. Ciò consente ai pattern di corrispondere
-attraverso più livelli di directory. Quando \`**\` appare inserito direttamente in
-un pattern, può corrispondere a zero o più caratteri inclusi gli slash tra
-il testo letterale circostante.
+Il carattere jolly doppio asterisco \`**\` corrisponde attraverso i separatori
+di directory solo quando è adiacente a un separatore di directory (preceduto
+o seguito da uno slash). In questa forma, corrisponde a zero o più caratteri
+attraverso i livelli di directory. Per esempio, \`foo/**/bar\` corrisponde a
+\`foo/bar\`, \`foo/a/bar\` e \`foo/a/b/bar\`; \`**/build\` corrisponde a \`build\` e
+\`foo/bar/build\`; e \`src/**.js\` corrisponde a \`src/main.js\` e
+\`src/ui/components/main.js\`.
+La forma autonoma \`/**/\` non è accettata come pattern completo.
 .PP
-L\'uso più importante di \`**\` è nella forma speciale \`/**/\`. Questa corrisponde a
-zero o più livelli di directory completi, rendendo possibile la corrispondenza di file
-a qualsiasi profondità in un albero di directory senza conoscere l\'esatta struttura del percorso.
-Per esempio, il pattern \`src/**/main.js\` corrisponde a \`src/main.js\` (saltando
-zero directory), \`src/ui/main.js\` (saltando una directory), e
-\`src/ui/components/main.js\` (saltando due directory).
+Quando \`**\` non è adiacente a uno slash, si comporta come \`*\` e non
+corrisponde ai separatori di directory. Per esempio, \`**.jpg\` corrisponde a
+\`photo.jpg\` nella directory corrente, ma non corrisponde a \`dir/photo.jpg\`.
+Usa \`**/*.jpg\` per questo scopo.
 .PP
 Le classi di caratteri che usano le parentesi quadre \`[]\` corrispondono a un singolo carattere da un
 set o intervallo specificato. Come gli altri pattern a carattere singolo, esse
@@ -2092,8 +2093,8 @@ un punto esclamativo.
 .PP
 La distinzione fondamentale da ricordare è che \`*\`, \`?\` e le classi di caratteri
 rispettano tutti i confini delle directory e corrispondono solo all\'interno di un singolo
-componente del percorso, mentre \`**\` è l\'unico pattern che può corrispondere attraverso
-i separatori di directory.
+componente del percorso, mentre \`**\` può corrispondere attraverso i separatori di directory
+solo quando è adiacente a uno slash.
 .PP
 Esistono quattro diversi tipi di pattern:
 .TP
diff --git a/doc/snapraid-it.d b/doc/snapraid-it.d
index 212c508b..92b32446 100644
--- a/doc/snapraid-it.d
+++ b/doc/snapraid-it.d
@@ -1666,18 +1666,19 @@ Pattern
 	componente del percorso. Questo è il comportamento standard dei wildcard familiare
 	dal globbing della shell.
 
-	Il doppio asterisco `**` è più potente, corrisponde a qualsiasi sequenza di
-	caratteri inclusi i separatori di directory. Ciò consente ai pattern di corrispondere
-	attraverso più livelli di directory. Quando `**` appare inserito direttamente in
-	un pattern, può corrispondere a zero o più caratteri inclusi gli slash tra
-	il testo letterale circostante.
+	Il carattere jolly doppio asterisco `**` corrisponde attraverso i separatori
+	di directory solo quando è adiacente a un separatore di directory (preceduto
+	o seguito da uno slash). In questa forma, corrisponde a zero o più caratteri
+	attraverso i livelli di directory. Per esempio, `foo/**/bar` corrisponde a
+	`foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corrisponde a `build` e
+	`foo/bar/build`; e `src/**.js` corrisponde a `src/main.js` e
+	`src/ui/components/main.js`.
+	La forma autonoma `/**/` non è accettata come pattern completo.
 
-	L'uso più importante di `**` è nella forma speciale `/**/`. Questa corrisponde a
-	zero o più livelli di directory completi, rendendo possibile la corrispondenza di file
-	a qualsiasi profondità in un albero di directory senza conoscere l'esatta struttura del percorso.
-	Per esempio, il pattern `src/**/main.js` corrisponde a `src/main.js` (saltando
-	zero directory), `src/ui/main.js` (saltando una directory), e
-	`src/ui/components/main.js` (saltando due directory).
+	Quando `**` non è adiacente a uno slash, si comporta come `*` e non
+	corrisponde ai separatori di directory. Per esempio, `**.jpg` corrisponde a
+	`photo.jpg` nella directory corrente, ma non corrisponde a `dir/photo.jpg`.
+	Usa `**/*.jpg` per questo scopo.
 
 	Le classi di caratteri che usano le parentesi quadre `[]` corrispondono a un singolo carattere da un
 	set o intervallo specificato. Come gli altri pattern a carattere singolo, esse
@@ -1686,8 +1687,8 @@ Pattern
 
 	La distinzione fondamentale da ricordare è che `*`, `?` e le classi di caratteri
 	rispettano tutti i confini delle directory e corrispondono solo all'interno di un singolo
-	componente del percorso, mentre `**` è l'unico pattern che può corrispondere attraverso
-	i separatori di directory.
+	componente del percorso, mentre `**` può corrispondere attraverso i separatori di directory
+	solo quando è adiacente a uno slash.
 
 	Esistono quattro diversi tipi di pattern:
 
diff --git a/doc/snapraid-it.txt b/doc/snapraid-it.txt
index 7c09e3aa..a744df1f 100644
--- a/doc/snapraid-it.txt
+++ b/doc/snapraid-it.txt
@@ -1779,18 +1779,19 @@ slash in avanti, rendendolo adatto per la corrispondenza all'interno di un singo
 componente del percorso. Questo è il comportamento standard dei wildcard familiare
 dal globbing della shell.
 
-Il doppio asterisco `**` è più potente, corrisponde a qualsiasi sequenza di
-caratteri inclusi i separatori di directory. Ciò consente ai pattern di corrispondere
-attraverso più livelli di directory. Quando `**` appare inserito direttamente in
-un pattern, può corrispondere a zero o più caratteri inclusi gli slash tra
-il testo letterale circostante.
+Il carattere jolly doppio asterisco `**` corrisponde attraverso i separatori
+di directory solo quando è adiacente a un separatore di directory (preceduto
+o seguito da uno slash). In questa forma, corrisponde a zero o più caratteri
+attraverso i livelli di directory. Per esempio, `foo/**/bar` corrisponde a
+`foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corrisponde a `build` e
+`foo/bar/build`; e `src/**.js` corrisponde a `src/main.js` e
+`src/ui/components/main.js`.
+La forma autonoma `/**/` non è accettata come pattern completo.
 
-L'uso più importante di `**` è nella forma speciale `/**/`. Questa corrisponde a
-zero o più livelli di directory completi, rendendo possibile la corrispondenza di file
-a qualsiasi profondità in un albero di directory senza conoscere l'esatta struttura del percorso.
-Per esempio, il pattern `src/**/main.js` corrisponde a `src/main.js` (saltando
-zero directory), `src/ui/main.js` (saltando una directory), e
-`src/ui/components/main.js` (saltando due directory).
+Quando `**` non è adiacente a uno slash, si comporta come `*` e non
+corrisponde ai separatori di directory. Per esempio, `**.jpg` corrisponde a
+`photo.jpg` nella directory corrente, ma non corrisponde a `dir/photo.jpg`.
+Usa `**/*.jpg` per questo scopo.
 
 Le classi di caratteri che usano le parentesi quadre `[]` corrispondono a un singolo carattere da un
 set o intervallo specificato. Come gli altri pattern a carattere singolo, esse
@@ -1799,8 +1800,8 @@ un punto esclamativo.
 
 La distinzione fondamentale da ricordare è che `*`, `?` e le classi di caratteri
 rispettano tutti i confini delle directory e corrispondono solo all'interno di un singolo
-componente del percorso, mentre `**` è l'unico pattern che può corrispondere attraverso
-i separatori di directory.
+componente del percorso, mentre `**` può corrispondere attraverso i separatori di directory
+solo quando è adiacente a uno slash.
 
 Esistono quattro diversi tipi di pattern:
 
diff --git a/doc/snapraid-ja.1 b/doc/snapraid-ja.1
index 0cd47ae7..1530b957 100644
--- a/doc/snapraid-ja.1
+++ b/doc/snapraid-ja.1
@@ -1848,17 +1848,18 @@ ZFSでは標準の \`.zfs/snapshot/\` が使用されます。
 単一のパスコンポーネント内での一致に適しています。これは、シェルの
 グロブでおなじみの標準的なワイルドカードの動作です。
 .PP
-ダブルアスタリスク \`**\` はより強力で、ディレクトリ区切り文字を含む
-任意の文字列に一致します。これにより、パターンが複数のディレクトリレベルを
-またいで一致できるようになります。\`**\` がパターン内に直接埋め込まれている場合、
-周囲のリテラルテキストの間にあるスラッシュを含む0文字以上の文字に一致します。
+ダブルアスタリスクのワイルドカード \`**\` は、ディレクトリ区切り文字に隣接
+している場合（スラッシュの前または後にある場合）にのみ、ディレクトリ区切り
+文字をまたいで一致します。この形式では、複数のディレクトリレベルにわたって
+0個以上の文字に一致します。例えば、\`foo/**/bar\` は \`foo/bar\`、\`foo/a/bar\`、
+および \`foo/a/b/bar\` に一致し、\`**/build\` は \`build\` および \`foo/bar/build\` に
+一致し、\`src/**.js\` は \`src/main.js\` および \`src/ui/components/main.js\` に一致します。
+単独の形式 \`/**/\` は完全なパターンとして受け入れられません。
 .PP
-\`**\` の最も重要な使い方は、特別な形式である \`/**/\` です。これは
-0個以上の完全なディレクトリレベルに一致し、正確なパス構造を知らなくても、
-ディレクトリツリー内の任意の深さにあるファイルと一致させることができます。
-例えば、パターン \`src/**/main.js\` は \`src/main.js\`（ディレクトリを0個スキップ）、
-\`src/ui/main.js\`（1個スキップ）、\`src/ui/components/main.js\`（2個スキップ）
-に一致します。
+\`**\` がスラッシュに隣接していない場合、\`*\` と同様に動作し、ディレクトリ区切り
+文字には一致しません。例えば、\`**.jpg\` はカレントディレクトリ内の \`photo.jpg\` に
+一致しますが、\`dir/photo.jpg\` には一致しません。その目的には \`**/*.jpg\` を
+使用してください。
 .PP
 角括弧 \`[]\` を使用した文字クラスは、指定されたセットまたは範囲の
 任意の1文字に一致します。他の単一文字パターンと同様に、
@@ -1867,7 +1868,8 @@ ZFSでは標準の \`.zfs/snapshot/\` が使用されます。
 .PP
 覚えておくべき根本的な違いは、\`*\`、\`?\`、および文字クラスはすべて
 ディレクトリの境界を尊重し、単一のパスコンポーネント内でのみ一致するのに対し、
-\`**\` はディレクトリ区切り文字をまたいで一致できる唯一のパターンであるということです。
+\`**\` はスラッシュに隣接している場合にのみディレクトリ区切り文字を
+またいで一致できるということです。
 .PP
 4つの異なる種類のパターンがあります。
 .TP
diff --git a/doc/snapraid-ja.d b/doc/snapraid-ja.d
index 60958f85..8bddd0fb 100644
--- a/doc/snapraid-ja.d
+++ b/doc/snapraid-ja.d
@@ -1453,17 +1453,18 @@ Name{number}
 	単一のパスコンポーネント内での一致に適しています。これは、シェルの
 	グロブでおなじみの標準的なワイルドカードの動作です。
 
-	ダブルアスタリスク `**` はより強力で、ディレクトリ区切り文字を含む
-	任意の文字列に一致します。これにより、パターンが複数のディレクトリレベルを
-	またいで一致できるようになります。`**` がパターン内に直接埋め込まれている場合、
-	周囲のリテラルテキストの間にあるスラッシュを含む0文字以上の文字に一致します。
+	ダブルアスタリスクのワイルドカード `**` は、ディレクトリ区切り文字に隣接
+	している場合（スラッシュの前または後にある場合）にのみ、ディレクトリ区切り
+	文字をまたいで一致します。この形式では、複数のディレクトリレベルにわたって
+	0個以上の文字に一致します。例えば、`foo/**/bar` は `foo/bar`、`foo/a/bar`、
+	および `foo/a/b/bar` に一致し、`**/build` は `build` および `foo/bar/build` に
+	一致し、`src/**.js` は `src/main.js` および `src/ui/components/main.js` に一致します。
+	単独の形式 `/**/` は完全なパターンとして受け入れられません。
 
-	`**` の最も重要な使い方は、特別な形式である `/**/` です。これは
-	0個以上の完全なディレクトリレベルに一致し、正確なパス構造を知らなくても、
-	ディレクトリツリー内の任意の深さにあるファイルと一致させることができます。
-	例えば、パターン `src/**/main.js` は `src/main.js`（ディレクトリを0個スキップ）、
-	`src/ui/main.js`（1個スキップ）、`src/ui/components/main.js`（2個スキップ）
-	に一致します。
+	`**` がスラッシュに隣接していない場合、`*` と同様に動作し、ディレクトリ区切り
+	文字には一致しません。例えば、`**.jpg` はカレントディレクトリ内の `photo.jpg` に
+	一致しますが、`dir/photo.jpg` には一致しません。その目的には `**/*.jpg` を
+	使用してください。
 
 	角括弧 `[]` を使用した文字クラスは、指定されたセットまたは範囲の
 	任意の1文字に一致します。他の単一文字パターンと同様に、
@@ -1472,7 +1473,8 @@ Name{number}
 
 	覚えておくべき根本的な違いは、`*`、`?`、および文字クラスはすべて
 	ディレクトリの境界を尊重し、単一のパスコンポーネント内でのみ一致するのに対し、
-	`**` はディレクトリ区切り文字をまたいで一致できる唯一のパターンであるということです。
+	`**` はスラッシュに隣接している場合にのみディレクトリ区切り文字を
+	またいで一致できるということです。
 
 	4つの異なる種類のパターンがあります。
 
diff --git a/doc/snapraid-ja.txt b/doc/snapraid-ja.txt
index 49d2eba9..87adbbe8 100644
--- a/doc/snapraid-ja.txt
+++ b/doc/snapraid-ja.txt
@@ -1566,17 +1566,18 @@ ZFSでは標準の `.zfs/snapshot/` が使用されます。
 単一のパスコンポーネント内での一致に適しています。これは、シェルの
 グロブでおなじみの標準的なワイルドカードの動作です。
 
-ダブルアスタリスク `**` はより強力で、ディレクトリ区切り文字を含む
-任意の文字列に一致します。これにより、パターンが複数のディレクトリレベルを
-またいで一致できるようになります。`**` がパターン内に直接埋め込まれている場合、
-周囲のリテラルテキストの間にあるスラッシュを含む0文字以上の文字に一致します。
+ダブルアスタリスクのワイルドカード `**` は、ディレクトリ区切り文字に隣接
+している場合（スラッシュの前または後にある場合）にのみ、ディレクトリ区切り
+文字をまたいで一致します。この形式では、複数のディレクトリレベルにわたって
+0個以上の文字に一致します。例えば、`foo/**/bar` は `foo/bar`、`foo/a/bar`、
+および `foo/a/b/bar` に一致し、`**/build` は `build` および `foo/bar/build` に
+一致し、`src/**.js` は `src/main.js` および `src/ui/components/main.js` に一致します。
+単独の形式 `/**/` は完全なパターンとして受け入れられません。
 
-`**` の最も重要な使い方は、特別な形式である `/**/` です。これは
-0個以上の完全なディレクトリレベルに一致し、正確なパス構造を知らなくても、
-ディレクトリツリー内の任意の深さにあるファイルと一致させることができます。
-例えば、パターン `src/**/main.js` は `src/main.js`（ディレクトリを0個スキップ）、
-`src/ui/main.js`（1個スキップ）、`src/ui/components/main.js`（2個スキップ）
-に一致します。
+`**` がスラッシュに隣接していない場合、`*` と同様に動作し、ディレクトリ区切り
+文字には一致しません。例えば、`**.jpg` はカレントディレクトリ内の `photo.jpg` に
+一致しますが、`dir/photo.jpg` には一致しません。その目的には `**/*.jpg` を
+使用してください。
 
 角括弧 `[]` を使用した文字クラスは、指定されたセットまたは範囲の
 任意の1文字に一致します。他の単一文字パターンと同様に、
@@ -1585,7 +1586,8 @@ ZFSでは標準の `.zfs/snapshot/` が使用されます。
 
 覚えておくべき根本的な違いは、`*`、`?`、および文字クラスはすべて
 ディレクトリの境界を尊重し、単一のパスコンポーネント内でのみ一致するのに対し、
-`**` はディレクトリ区切り文字をまたいで一致できる唯一のパターンであるということです。
+`**` はスラッシュに隣接している場合にのみディレクトリ区切り文字を
+またいで一致できるということです。
 
 4つの異なる種類のパターンがあります。
 
diff --git a/doc/snapraid-ko.1 b/doc/snapraid-ko.1
index 54655994..6a09bb2b 100644
--- a/doc/snapraid-ko.1
+++ b/doc/snapraid-ko.1
@@ -1893,17 +1893,18 @@ ZFS에서는 표준 \`.zfs/snapshot/\` 이 사용됩니다.
 내에서의 일치에 적합합니다. 이는 쉘 글로빙에서 익숙한 표준 와일드카드
 동작입니다.
 .PP
-이중 별표 \`**\`는 더 강력하며 디렉토리 구분 기호를 포함한 모든 문자
-시퀀스와 일치합니다. 이를 통해 패턴이 여러 디렉토리 수준에서 일치할 수
-있습니다. \`**\`가 패턴 내에 직접 포함된 경우, 주변 리터럴 텍스트 사이의
-슬래시를 포함하여 0개 이상의 문자와 일치할 수 있습니다.
+이중 별표 와일드카드 \`**\`는 디렉토리 구분 기호에 인접해 있는 경우(슬래시
+앞이나 뒤에 오는 경우)에만 디렉토리 구분 기호를 가로질러 일치합니다.
+이 형식에서는 여러 디렉토리 수준에 걸쳐 0개 이상의 문자와 일치합니다.
+예를 들어, \`foo/**/bar\`는 \`foo/bar\`, \`foo/a/bar\` 및 \`foo/a/b/bar\`와 일치하고,
+\`**/build\`는 \`build\` 및 \`foo/bar/build\`와 일치하며, \`src/**.js\`는 \`src/main.js\` 및
+\`src/ui/components/main.js\`와 일치합니다.
+독립형 형식인 \`/**/\`는 완전한 패턴으로 허용되지 않습니다.
 .PP
-\`**\`의 가장 중요한 용도는 특수 형식인 \`/**/\`입니다. 이는 0개 이상의
-전체 디렉토리 수준과 일치하므로 정확한 경로 구조를 모르더라도
-디렉토리 트리의 모든 깊이에서 파일과 일치시킬 수 있습니다.
-예를 들어, \`src/**/main.js\` 패턴은 \`src/main.js\`(0개의 디렉토리 건너뜀),
-\`src/ui/main.js\`(1개의 디렉토리 건너뜀), \`src/ui/components/main.js\`
-(2개의 디렉토리 건너뜀)와 일치합니다.
+\`**\`가 슬래시에 인접하지 않은 경우 \`*\`처럼 작동하며 디렉토리 구분 기호와
+일치하지 않습니다. 예를 들어, \`**.jpg\`는 현재 디렉토리의 \`photo.jpg\`와는
+일치하지만 \`dir/photo.jpg\`와는 일치하지 않습니다. 해당 용도로는 \`**/*.jpg\`를
+사용하십시오.
 .PP
 대괄호 \`[]\`를 사용하는 문자 클래스는 지정된 세트 또는 범위에서
 단일 문자와 일치합니다. 다른 단일 문자 패턴과 마찬가지로 디렉토리
@@ -1912,7 +1913,8 @@ ZFS에서는 표준 \`.zfs/snapshot/\` 이 사용됩니다.
 .PP
 기억해야 할 근본적인 차이점은 \`*\`, \`?\` 및 문자 클래스는 모두
 디렉토리 경계를 준수하고 단일 경로 구성 요소 내에서만 일치하는 반면,
-\`**\`는 디렉토리 구분 기호를 가로질러 일치할 수 있는 유일한 패턴이라는 것입니다.
+\`**\`는 슬래시에 인접해 있는 경우에만 디렉토리 구분 기호를 가로질러
+일치할 수 있다는 것입니다.
 .PP
 네 가지 유형의 패턴이 있습니다:
 .TP
diff --git a/doc/snapraid-ko.d b/doc/snapraid-ko.d
index 694b0e74..753207d8 100644
--- a/doc/snapraid-ko.d
+++ b/doc/snapraid-ko.d
@@ -1498,17 +1498,18 @@ Name{number}
 	내에서의 일치에 적합합니다. 이는 쉘 글로빙에서 익숙한 표준 와일드카드
 	동작입니다.
 
-	이중 별표 `**`는 더 강력하며 디렉토리 구분 기호를 포함한 모든 문자
-	시퀀스와 일치합니다. 이를 통해 패턴이 여러 디렉토리 수준에서 일치할 수
-	있습니다. `**`가 패턴 내에 직접 포함된 경우, 주변 리터럴 텍스트 사이의
-	슬래시를 포함하여 0개 이상의 문자와 일치할 수 있습니다.
+	이중 별표 와일드카드 `**`는 디렉토리 구분 기호에 인접해 있는 경우(슬래시
+	앞이나 뒤에 오는 경우)에만 디렉토리 구분 기호를 가로질러 일치합니다.
+	이 형식에서는 여러 디렉토리 수준에 걸쳐 0개 이상의 문자와 일치합니다.
+	예를 들어, `foo/**/bar`는 `foo/bar`, `foo/a/bar` 및 `foo/a/b/bar`와 일치하고,
+	`**/build`는 `build` 및 `foo/bar/build`와 일치하며, `src/**.js`는 `src/main.js` 및
+	`src/ui/components/main.js`와 일치합니다.
+	독립형 형식인 `/**/`는 완전한 패턴으로 허용되지 않습니다.
 
-	`**`의 가장 중요한 용도는 특수 형식인 `/**/`입니다. 이는 0개 이상의
-	전체 디렉토리 수준과 일치하므로 정확한 경로 구조를 모르더라도
-	디렉토리 트리의 모든 깊이에서 파일과 일치시킬 수 있습니다.
-	예를 들어, `src/**/main.js` 패턴은 `src/main.js`(0개의 디렉토리 건너뜀),
-	`src/ui/main.js`(1개의 디렉토리 건너뜀), `src/ui/components/main.js`
-	(2개의 디렉토리 건너뜀)와 일치합니다.
+	`**`가 슬래시에 인접하지 않은 경우 `*`처럼 작동하며 디렉토리 구분 기호와
+	일치하지 않습니다. 예를 들어, `**.jpg`는 현재 디렉토리의 `photo.jpg`와는
+	일치하지만 `dir/photo.jpg`와는 일치하지 않습니다. 해당 용도로는 `**/*.jpg`를
+	사용하십시오.
 
 	대괄호 `[]`를 사용하는 문자 클래스는 지정된 세트 또는 범위에서
 	단일 문자와 일치합니다. 다른 단일 문자 패턴과 마찬가지로 디렉토리
@@ -1517,7 +1518,8 @@ Name{number}
 
 	기억해야 할 근본적인 차이점은 `*`, `?` 및 문자 클래스는 모두
 	디렉토리 경계를 준수하고 단일 경로 구성 요소 내에서만 일치하는 반면,
-	`**`는 디렉토리 구분 기호를 가로질러 일치할 수 있는 유일한 패턴이라는 것입니다.
+	`**`는 슬래시에 인접해 있는 경우에만 디렉토리 구분 기호를 가로질러
+	일치할 수 있다는 것입니다.
 
 	네 가지 유형의 패턴이 있습니다:
 
diff --git a/doc/snapraid-ko.txt b/doc/snapraid-ko.txt
index ca56cc98..08f404fc 100644
--- a/doc/snapraid-ko.txt
+++ b/doc/snapraid-ko.txt
@@ -1611,17 +1611,18 @@ ZFS에서는 표준 `.zfs/snapshot/` 이 사용됩니다.
 내에서의 일치에 적합합니다. 이는 쉘 글로빙에서 익숙한 표준 와일드카드
 동작입니다.
 
-이중 별표 `**`는 더 강력하며 디렉토리 구분 기호를 포함한 모든 문자
-시퀀스와 일치합니다. 이를 통해 패턴이 여러 디렉토리 수준에서 일치할 수
-있습니다. `**`가 패턴 내에 직접 포함된 경우, 주변 리터럴 텍스트 사이의
-슬래시를 포함하여 0개 이상의 문자와 일치할 수 있습니다.
+이중 별표 와일드카드 `**`는 디렉토리 구분 기호에 인접해 있는 경우(슬래시
+앞이나 뒤에 오는 경우)에만 디렉토리 구분 기호를 가로질러 일치합니다.
+이 형식에서는 여러 디렉토리 수준에 걸쳐 0개 이상의 문자와 일치합니다.
+예를 들어, `foo/**/bar`는 `foo/bar`, `foo/a/bar` 및 `foo/a/b/bar`와 일치하고,
+`**/build`는 `build` 및 `foo/bar/build`와 일치하며, `src/**.js`는 `src/main.js` 및
+`src/ui/components/main.js`와 일치합니다.
+독립형 형식인 `/**/`는 완전한 패턴으로 허용되지 않습니다.
 
-`**`의 가장 중요한 용도는 특수 형식인 `/**/`입니다. 이는 0개 이상의
-전체 디렉토리 수준과 일치하므로 정확한 경로 구조를 모르더라도
-디렉토리 트리의 모든 깊이에서 파일과 일치시킬 수 있습니다.
-예를 들어, `src/**/main.js` 패턴은 `src/main.js`(0개의 디렉토리 건너뜀),
-`src/ui/main.js`(1개의 디렉토리 건너뜀), `src/ui/components/main.js`
-(2개의 디렉토리 건너뜀)와 일치합니다.
+`**`가 슬래시에 인접하지 않은 경우 `*`처럼 작동하며 디렉토리 구분 기호와
+일치하지 않습니다. 예를 들어, `**.jpg`는 현재 디렉토리의 `photo.jpg`와는
+일치하지만 `dir/photo.jpg`와는 일치하지 않습니다. 해당 용도로는 `**/*.jpg`를
+사용하십시오.
 
 대괄호 `[]`를 사용하는 문자 클래스는 지정된 세트 또는 범위에서
 단일 문자와 일치합니다. 다른 단일 문자 패턴과 마찬가지로 디렉토리
@@ -1630,7 +1631,8 @@ ZFS에서는 표준 `.zfs/snapshot/` 이 사용됩니다.
 
 기억해야 할 근본적인 차이점은 `*`, `?` 및 문자 클래스는 모두
 디렉토리 경계를 준수하고 단일 경로 구성 요소 내에서만 일치하는 반면,
-`**`는 디렉토리 구분 기호를 가로질러 일치할 수 있는 유일한 패턴이라는 것입니다.
+`**`는 슬래시에 인접해 있는 경우에만 디렉토리 구분 기호를 가로질러
+일치할 수 있다는 것입니다.
 
 네 가지 유형의 패턴이 있습니다:
 
diff --git a/doc/snapraid-pl.1 b/doc/snapraid-pl.1
index 2ffd2f9a..d49b9fd7 100644
--- a/doc/snapraid-pl.1
+++ b/doc/snapraid-pl.1
@@ -1970,18 +1970,18 @@ ukośniku, co czyni ją odpowiednią do dopasowywania w obrębie jednego
 składnika ścieżki. Jest to standardowe zachowanie symboli wieloznacznych znane
 z globbingu powłoki (shell).
 .PP
-Podwójna gwiazdka \`**\` jest potężniejsza, dopasowuje dowolną sekwencję
-znaków, w tym separatory katalogów. Pozwala to wzorcom dopasowywać się
-na wielu poziomach katalogów. Gdy \`**\` pojawia się bezpośrednio wewnątrz
-wzorca, może dopasować zero lub więcej znaków, w tym ukośniki między
-otaczającym tekstem dosłownym.
+Symbol wieloznaczny podwójnej gwiazdki \`**\` dopasowuje się poprzez separatory
+katalogów tylko wtedy, gdy sąsiaduje z separatorem katalogów (jest poprzedzony
+lub zakończony ukośnikiem). W tej formie dopasowuje zero lub więcej znaków
+na wielu poziomach katalogów. Na przykład \`foo/**/bar\` dopasowuje \`foo/bar\`,
+\`foo/a/bar\` oraz \`foo/a/b/bar\`; \`**/build\` dopasowuje \`build\` oraz
+\`foo/bar/build\`; a \`src/**.js\` dopasowuje \`src/main.js\` oraz
+\`src/ui/components/main.js\`.
+Samodzielna forma \`/**/\` nie jest akceptowana jako kompletny wzorzec.
 .PP
-Najważniejszym zastosowaniem \`**\` jest specjalna forma \`/**/\`. Dopasowuje ona
-zero lub więcej pełnych poziomów katalogów, umożliwiając dopasowanie plików
-na dowolnej głębokości w drzewie katalogów bez znajomości dokładnej struktury ścieżki.
-Na przykład wzorzec \`src/**/main.js\` pasuje do \`src/main.js\` (pomijając
-zero katalogów), \`src/ui/main.js\` (pomijając jeden katalog) oraz
-\`src/ui/components/main.js\` (pomijając dwa katalogi).
+Gdy \`**\` nie sąsiaduje z ukośnikiem, zachowuje się jak \`*\` i nie dopasowuje
+separatorów katalogów. Na przykład \`**.jpg\` dopasowuje \`photo.jpg\` w bieżącym
+katalogu, ale nie pasuje do \`dir/photo.jpg\`. W tym celu należy użyć \`**/*.jpg\`.
 .PP
 Klasy znaków używające nawiasów kwadratowych \`[]\` dopasowują pojedynczy znak z
 określonego zestawu lub zakresu. Podobnie jak inne wzorce pojedynczych znaków,
@@ -1990,8 +1990,8 @@ wykrzyknika.
 .PP
 Podstawową różnicą, o której należy pamiętać, jest to, że \`*\`, \`?\` i klasy znaków
 wszystkie respektują granice katalogów i dopasowują się tylko w obrębie jednego
-składnika ścieżki, podczas gdy \`**\` jest jedynym wzorcem, który może dopasowywać się poprzez
-separatory katalogów.
+składnika ścieżki, podczas gdy \`**\` może dopasowywać się poprzez separatory
+katalogów tylko wtedy, gdy sąsiaduje z ukośnikiem.
 .PP
 Istnieją cztery różne typy wzorców:
 .TP
diff --git a/doc/snapraid-pl.d b/doc/snapraid-pl.d
index 0effe1cb..14d5d730 100644
--- a/doc/snapraid-pl.d
+++ b/doc/snapraid-pl.d
@@ -1575,18 +1575,18 @@ Wzorce (Pattern)
 	składnika ścieżki. Jest to standardowe zachowanie symboli wieloznacznych znane
 	z globbingu powłoki (shell).
 
-	Podwójna gwiazdka `**` jest potężniejsza, dopasowuje dowolną sekwencję
-	znaków, w tym separatory katalogów. Pozwala to wzorcom dopasowywać się
-	na wielu poziomach katalogów. Gdy `**` pojawia się bezpośrednio wewnątrz
-	wzorca, może dopasować zero lub więcej znaków, w tym ukośniki między
-	otaczającym tekstem dosłownym.
+	Symbol wieloznaczny podwójnej gwiazdki `**` dopasowuje się poprzez separatory
+	katalogów tylko wtedy, gdy sąsiaduje z separatorem katalogów (jest poprzedzony
+	lub zakończony ukośnikiem). W tej formie dopasowuje zero lub więcej znaków
+	na wielu poziomach katalogów. Na przykład `foo/**/bar` dopasowuje `foo/bar`,
+	`foo/a/bar` oraz `foo/a/b/bar`; `**/build` dopasowuje `build` oraz
+	`foo/bar/build`; a `src/**.js` dopasowuje `src/main.js` oraz
+	`src/ui/components/main.js`.
+	Samodzielna forma `/**/` nie jest akceptowana jako kompletny wzorzec.
 
-	Najważniejszym zastosowaniem `**` jest specjalna forma `/**/`. Dopasowuje ona
-	zero lub więcej pełnych poziomów katalogów, umożliwiając dopasowanie plików
-	na dowolnej głębokości w drzewie katalogów bez znajomości dokładnej struktury ścieżki.
-	Na przykład wzorzec `src/**/main.js` pasuje do `src/main.js` (pomijając
-	zero katalogów), `src/ui/main.js` (pomijając jeden katalog) oraz
-	`src/ui/components/main.js` (pomijając dwa katalogi).
+	Gdy `**` nie sąsiaduje z ukośnikiem, zachowuje się jak `*` i nie dopasowuje
+	separatorów katalogów. Na przykład `**.jpg` dopasowuje `photo.jpg` w bieżącym
+	katalogu, ale nie pasuje do `dir/photo.jpg`. W tym celu należy użyć `**/*.jpg`.
 
 	Klasy znaków używające nawiasów kwadratowych `[]` dopasowują pojedynczy znak z
 	określonego zestawu lub zakresu. Podobnie jak inne wzorce pojedynczych znaków,
@@ -1595,8 +1595,8 @@ Wzorce (Pattern)
 
 	Podstawową różnicą, o której należy pamiętać, jest to, że `*`, `?` i klasy znaków
 	wszystkie respektują granice katalogów i dopasowują się tylko w obrębie jednego
-	składnika ścieżki, podczas gdy `**` jest jedynym wzorcem, który może dopasowywać się poprzez
-	separatory katalogów.
+	składnika ścieżki, podczas gdy `**` może dopasowywać się poprzez separatory
+	katalogów tylko wtedy, gdy sąsiaduje z ukośnikiem.
 
 	Istnieją cztery różne typy wzorców:
 
diff --git a/doc/snapraid-pl.txt b/doc/snapraid-pl.txt
index 2dd45901..42533df0 100644
--- a/doc/snapraid-pl.txt
+++ b/doc/snapraid-pl.txt
@@ -1688,18 +1688,18 @@ ukośniku, co czyni ją odpowiednią do dopasowywania w obrębie jednego
 składnika ścieżki. Jest to standardowe zachowanie symboli wieloznacznych znane
 z globbingu powłoki (shell).
 
-Podwójna gwiazdka `**` jest potężniejsza, dopasowuje dowolną sekwencję
-znaków, w tym separatory katalogów. Pozwala to wzorcom dopasowywać się
-na wielu poziomach katalogów. Gdy `**` pojawia się bezpośrednio wewnątrz
-wzorca, może dopasować zero lub więcej znaków, w tym ukośniki między
-otaczającym tekstem dosłownym.
+Symbol wieloznaczny podwójnej gwiazdki `**` dopasowuje się poprzez separatory
+katalogów tylko wtedy, gdy sąsiaduje z separatorem katalogów (jest poprzedzony
+lub zakończony ukośnikiem). W tej formie dopasowuje zero lub więcej znaków
+na wielu poziomach katalogów. Na przykład `foo/**/bar` dopasowuje `foo/bar`,
+`foo/a/bar` oraz `foo/a/b/bar`; `**/build` dopasowuje `build` oraz
+`foo/bar/build`; a `src/**.js` dopasowuje `src/main.js` oraz
+`src/ui/components/main.js`.
+Samodzielna forma `/**/` nie jest akceptowana jako kompletny wzorzec.
 
-Najważniejszym zastosowaniem `**` jest specjalna forma `/**/`. Dopasowuje ona
-zero lub więcej pełnych poziomów katalogów, umożliwiając dopasowanie plików
-na dowolnej głębokości w drzewie katalogów bez znajomości dokładnej struktury ścieżki.
-Na przykład wzorzec `src/**/main.js` pasuje do `src/main.js` (pomijając
-zero katalogów), `src/ui/main.js` (pomijając jeden katalog) oraz
-`src/ui/components/main.js` (pomijając dwa katalogi).
+Gdy `**` nie sąsiaduje z ukośnikiem, zachowuje się jak `*` i nie dopasowuje
+separatorów katalogów. Na przykład `**.jpg` dopasowuje `photo.jpg` w bieżącym
+katalogu, ale nie pasuje do `dir/photo.jpg`. W tym celu należy użyć `**/*.jpg`.
 
 Klasy znaków używające nawiasów kwadratowych `[]` dopasowują pojedynczy znak z
 określonego zestawu lub zakresu. Podobnie jak inne wzorce pojedynczych znaków,
@@ -1708,8 +1708,8 @@ wykrzyknika.
 
 Podstawową różnicą, o której należy pamiętać, jest to, że `*`, `?` i klasy znaków
 wszystkie respektują granice katalogów i dopasowują się tylko w obrębie jednego
-składnika ścieżki, podczas gdy `**` jest jedynym wzorcem, który może dopasowywać się poprzez
-separatory katalogów.
+składnika ścieżki, podczas gdy `**` może dopasowywać się poprzez separatory
+katalogów tylko wtedy, gdy sąsiaduje z ukośnikiem.
 
 Istnieją cztery różne typy wzorców:
 
diff --git a/doc/snapraid-pt.1 b/doc/snapraid-pt.1
index 6f2d3e8c..c7385b00 100644
--- a/doc/snapraid-pt.1
+++ b/doc/snapraid-pt.1
@@ -2008,18 +2008,19 @@ barra invertida, tornando\-o adequado para correspondência dentro de um único
 componente de caminho. Este é o comportamento padrão de curinga familiar do
 globbing de shell.
 .PP
-O asterisco duplo \`**\` é mais poderoso, ele corresponde a qualquer sequência de
-caracteres, incluindo separadores de diretórios. Isso permite que os padrões correspondam
-em vários níveis de diretório. Quando o \`**\` aparece incorporado diretamente em
-um padrão, ele pode corresponder a zero ou mais caracteres, incluindo barras entre
-o texto literal circundante.
+O curinga de asterisco duplo \`**\` corresponde através de separadores de
+diretório apenas quando for adjacente a um separador de diretório (precedido
+ou seguido por uma barra). Nessa forma, ele corresponde a zero ou mais
+caracteres através de níveis de diretório. Por exemplo, \`foo/**/bar\`
+corresponde a \`foo/bar\`, \`foo/a/bar\` e \`foo/a/b/bar\`; \`**/build\` corresponde a
+\`build\` e \`foo/bar/build\`; e \`src/**.js\` corresponde a \`src/main.js\` e
+\`src/ui/components/main.js\`.
+A forma avulsa \`/**/\` não é aceita como um padrão completo.
 .PP
-O uso mais importante do \`**\` é na forma especial \`/**/\`. Isso corresponde a
-zero ou mais níveis de diretório completos, tornando possível corresponder arquivos
-em qualquer profundidade em uma árvore de diretórios sem conhecer a estrutura exata do caminho.
-Por exemplo, o padrão \`src/**/main.js\` corresponde a \`src/main.js\` (pulando
-zero diretórios), \`src/ui/main.js\` (pulando um diretório) e
-\`src/ui/components/main.js\` (pulando dois diretórios).
+Quando \`**\` não for adjacente a uma barra, ele se comporta como \`*\` e não
+corresponde a separadores de diretório. Por exemplo, \`**.jpg\` corresponde a
+\`photo.jpg\` no diretório atual, mas não corresponde a \`dir/photo.jpg\`. Use
+\`**/*.jpg\` para essa finalidade.
 .PP
 Classes de caracteres usando colchetes \`[]\` correspondem a um único caractere de um
 conjunto ou intervalo especificado. Como os outros padrões de caractere único, elas
@@ -2028,8 +2029,8 @@ um ponto de exclamação.
 .PP
 A distinção fundamental a ser lembrada é que \`*\`, \`?\` e classes de caracteres
 respeitam os limites do diretório e correspondem apenas dentro de um único
-componente de caminho, enquanto \`**\` é o único padrão que pode corresponder através de
-separadores de diretório.
+componente de caminho, enquanto \`**\` só pode corresponder através de separadores
+de diretório quando for adjacente a uma barra.
 .PP
 Existem quatro tipos diferentes de padrões:
 .TP
diff --git a/doc/snapraid-pt.d b/doc/snapraid-pt.d
index a4993a78..cd57e933 100644
--- a/doc/snapraid-pt.d
+++ b/doc/snapraid-pt.d
@@ -1613,18 +1613,19 @@ Padrão (Pattern)
 	componente de caminho. Este é o comportamento padrão de curinga familiar do
 	globbing de shell.
 
-	O asterisco duplo `**` é mais poderoso, ele corresponde a qualquer sequência de
-	caracteres, incluindo separadores de diretórios. Isso permite que os padrões correspondam
-	em vários níveis de diretório. Quando o `**` aparece incorporado diretamente em
-	um padrão, ele pode corresponder a zero ou mais caracteres, incluindo barras entre
-	o texto literal circundante.
+	O curinga de asterisco duplo `**` corresponde através de separadores de
+	diretório apenas quando for adjacente a um separador de diretório (precedido
+	ou seguido por uma barra). Nessa forma, ele corresponde a zero ou mais
+	caracteres através de níveis de diretório. Por exemplo, `foo/**/bar`
+	corresponde a `foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corresponde a
+	`build` e `foo/bar/build`; e `src/**.js` corresponde a `src/main.js` e
+	`src/ui/components/main.js`.
+	A forma avulsa `/**/` não é aceita como um padrão completo.
 
-	O uso mais importante do `**` é na forma especial `/**/`. Isso corresponde a
-	zero ou mais níveis de diretório completos, tornando possível corresponder arquivos
-	em qualquer profundidade em uma árvore de diretórios sem conhecer a estrutura exata do caminho.
-	Por exemplo, o padrão `src/**/main.js` corresponde a `src/main.js` (pulando
-	zero diretórios), `src/ui/main.js` (pulando um diretório) e
-	`src/ui/components/main.js` (pulando dois diretórios).
+	Quando `**` não for adjacente a uma barra, ele se comporta como `*` e não
+	corresponde a separadores de diretório. Por exemplo, `**.jpg` corresponde a
+	`photo.jpg` no diretório atual, mas não corresponde a `dir/photo.jpg`. Use
+	`**/*.jpg` para essa finalidade.
 
 	Classes de caracteres usando colchetes `[]` correspondem a um único caractere de um
 	conjunto ou intervalo especificado. Como os outros padrões de caractere único, elas
@@ -1633,8 +1634,8 @@ Padrão (Pattern)
 
 	A distinção fundamental a ser lembrada é que `*`, `?` e classes de caracteres
 	respeitam os limites do diretório e correspondem apenas dentro de um único
-	componente de caminho, enquanto `**` é o único padrão que pode corresponder através de
-	separadores de diretório.
+	componente de caminho, enquanto `**` só pode corresponder através de separadores
+	de diretório quando for adjacente a uma barra.
 
 	Existem quatro tipos diferentes de padrões:
 
diff --git a/doc/snapraid-pt.txt b/doc/snapraid-pt.txt
index 57936d1e..a7705627 100644
--- a/doc/snapraid-pt.txt
+++ b/doc/snapraid-pt.txt
@@ -1726,18 +1726,19 @@ barra invertida, tornando-o adequado para correspondência dentro de um único
 componente de caminho. Este é o comportamento padrão de curinga familiar do
 globbing de shell.
 
-O asterisco duplo `**` é mais poderoso, ele corresponde a qualquer sequência de
-caracteres, incluindo separadores de diretórios. Isso permite que os padrões correspondam
-em vários níveis de diretório. Quando o `**` aparece incorporado diretamente em
-um padrão, ele pode corresponder a zero ou mais caracteres, incluindo barras entre
-o texto literal circundante.
+O curinga de asterisco duplo `**` corresponde através de separadores de
+diretório apenas quando for adjacente a um separador de diretório (precedido
+ou seguido por uma barra). Nessa forma, ele corresponde a zero ou mais
+caracteres através de níveis de diretório. Por exemplo, `foo/**/bar`
+corresponde a `foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corresponde a
+`build` e `foo/bar/build`; e `src/**.js` corresponde a `src/main.js` e
+`src/ui/components/main.js`.
+A forma avulsa `/**/` não é aceita como um padrão completo.
 
-O uso mais importante do `**` é na forma especial `/**/`. Isso corresponde a
-zero ou mais níveis de diretório completos, tornando possível corresponder arquivos
-em qualquer profundidade em uma árvore de diretórios sem conhecer a estrutura exata do caminho.
-Por exemplo, o padrão `src/**/main.js` corresponde a `src/main.js` (pulando
-zero diretórios), `src/ui/main.js` (pulando um diretório) e
-`src/ui/components/main.js` (pulando dois diretórios).
+Quando `**` não for adjacente a uma barra, ele se comporta como `*` e não
+corresponde a separadores de diretório. Por exemplo, `**.jpg` corresponde a
+`photo.jpg` no diretório atual, mas não corresponde a `dir/photo.jpg`. Use
+`**/*.jpg` para essa finalidade.
 
 Classes de caracteres usando colchetes `[]` correspondem a um único caractere de um
 conjunto ou intervalo especificado. Como os outros padrões de caractere único, elas
@@ -1746,8 +1747,8 @@ um ponto de exclamação.
 
 A distinção fundamental a ser lembrada é que `*`, `?` e classes de caracteres
 respeitam os limites do diretório e correspondem apenas dentro de um único
-componente de caminho, enquanto `**` é o único padrão que pode corresponder através de
-separadores de diretório.
+componente de caminho, enquanto `**` só pode corresponder através de separadores
+de diretório quando for adjacente a uma barra.
 
 Existem quatro tipos diferentes de padrões:
 
diff --git a/doc/snapraid-ro.1 b/doc/snapraid-ro.1
index e8417488..f7f80911 100644
--- a/doc/snapraid-ro.1
+++ b/doc/snapraid-ro.1
@@ -1968,18 +1968,19 @@ bara oblică (/), ceea ce îl face potrivit pentru potrivirea în cadrul unei si
 componente a căii. Acesta este comportamentul standard al metacaracterelor, familiar
 din shell globbing.
 .PP
-Asteriscul dublu \`**\` este mai puternic, se potrivește cu orice secvență de
-caractere, inclusiv separatori de directoare. Acest lucru permite modelelor să se potrivească
-pe mai multe niveluri de directoare. Când \`**\` apare inserat direct într\-un
-model, se poate potrivi cu zero sau mai multe caractere, inclusiv slash\-uri între
-textul literal înconjurător.
+Metacaracterul asterisc dublu \`**\` se potrivește peste separatorii de
+directoare numai atunci când este adiacent unui separator de directoare
+(precedat sau urmat de o bară oblică). În această formă, se potrivește cu
+zero sau mai multe caractere pe mai multe niveluri de directoare. De exemplu,
+\`foo/**/bar\` se potrivește cu \`foo/bar\`, \`foo/a/bar\` și \`foo/a/b/bar\`;
+\`**/build\` se potrivește cu \`build\` și \`foo/bar/build\`; iar \`src/**.js\` se
+potrivește cu \`src/main.js\` și \`src/ui/components/main.js\`.
+Forma de sine stătătoare \`/**/\` nu este acceptată ca un model complet.
 .PP
-Cea mai importantă utilizare a lui \`**\` este în forma specială \`/**/\`. Aceasta se potrivește cu
-zero sau mai multe niveluri complete de directoare, făcând posibilă potrivirea fișierelor
-la orice adâncime într\-un arbore de directoare fără a cunoaște structura exactă a căii.
-De exemplu, modelul \`src/**/main.js\` se potrivește cu \`src/main.js\` (sărind
-peste zero directoare), \`src/ui/main.js\` (sărind peste un director) și
-\`src/ui/components/main.js\` (sărind peste două directoare).
+Când \`**\` nu este adiacent unei bare oblice, se comportă ca \`*\` și nu se
+potrivește cu separatorii de directoare. De exemplu, \`**.jpg\` se potrivește cu
+\`photo.jpg\` în directorul curent, dar nu se potrivește cu \`dir/photo.jpg\`.
+Folosiți \`**/*.jpg\` în acest scop.
 .PP
 Clasele de caractere care utilizează paranteze pătrate \`[]\` se potrivesc cu un singur caracter dintr\-un
 set sau interval specificat. La fel ca și celelalte modele de un singur caracter, acestea
@@ -1988,8 +1989,8 @@ un semn de exclamare.
 .PP
 Distincția fundamentală de reținut este că \`*\`, \`?\` și clasele de caractere
 respectă toate limitele directoarelor și se potrivesc doar în cadrul unei singure
-componente a căii, în timp ce \`**\` este singurul model care se poate potrivi peste
-separatorii de directoare.
+componente a căii, în timp ce \`**\` se poate potrivi peste separatorii de directoare
+numai atunci când este adiacent unei bare oblice.
 .PP
 Există patru tipuri diferite de modele:
 .TP
diff --git a/doc/snapraid-ro.d b/doc/snapraid-ro.d
index 01d0fdf3..8675aaee 100644
--- a/doc/snapraid-ro.d
+++ b/doc/snapraid-ro.d
@@ -1573,18 +1573,19 @@ Model (Pattern)
 	componente a căii. Acesta este comportamentul standard al metacaracterelor, familiar
 	din shell globbing.
 
-	Asteriscul dublu `**` este mai puternic, se potrivește cu orice secvență de
-	caractere, inclusiv separatori de directoare. Acest lucru permite modelelor să se potrivească
-	pe mai multe niveluri de directoare. Când `**` apare inserat direct într-un
-	model, se poate potrivi cu zero sau mai multe caractere, inclusiv slash-uri între
-	textul literal înconjurător.
+	Metacaracterul asterisc dublu `**` se potrivește peste separatorii de
+	directoare numai atunci când este adiacent unui separator de directoare
+	(precedat sau urmat de o bară oblică). În această formă, se potrivește cu
+	zero sau mai multe caractere pe mai multe niveluri de directoare. De exemplu,
+	`foo/**/bar` se potrivește cu `foo/bar`, `foo/a/bar` și `foo/a/b/bar`;
+	`**/build` se potrivește cu `build` și `foo/bar/build`; iar `src/**.js` se
+	potrivește cu `src/main.js` și `src/ui/components/main.js`.
+	Forma de sine stătătoare `/**/` nu este acceptată ca un model complet.
 
-	Cea mai importantă utilizare a lui `**` este în forma specială `/**/`. Aceasta se potrivește cu
-	zero sau mai multe niveluri complete de directoare, făcând posibilă potrivirea fișierelor
-	la orice adâncime într-un arbore de directoare fără a cunoaște structura exactă a căii.
-	De exemplu, modelul `src/**/main.js` se potrivește cu `src/main.js` (sărind
-	peste zero directoare), `src/ui/main.js` (sărind peste un director) și
-	`src/ui/components/main.js` (sărind peste două directoare).
+	Când `**` nu este adiacent unei bare oblice, se comportă ca `*` și nu se
+	potrivește cu separatorii de directoare. De exemplu, `**.jpg` se potrivește cu
+	`photo.jpg` în directorul curent, dar nu se potrivește cu `dir/photo.jpg`.
+	Folosiți `**/*.jpg` în acest scop.
 
 	Clasele de caractere care utilizează paranteze pătrate `[]` se potrivesc cu un singur caracter dintr-un
 	set sau interval specificat. La fel ca și celelalte modele de un singur caracter, acestea
@@ -1593,8 +1594,8 @@ Model (Pattern)
 
 	Distincția fundamentală de reținut este că `*`, `?` și clasele de caractere
 	respectă toate limitele directoarelor și se potrivesc doar în cadrul unei singure
-	componente a căii, în timp ce `**` este singurul model care se poate potrivi peste
-	separatorii de directoare.
+	componente a căii, în timp ce `**` se poate potrivi peste separatorii de directoare
+	numai atunci când este adiacent unei bare oblice.
 
 	Există patru tipuri diferite de modele:
 
diff --git a/doc/snapraid-ro.txt b/doc/snapraid-ro.txt
index 31d1ca74..9a33ec2d 100644
--- a/doc/snapraid-ro.txt
+++ b/doc/snapraid-ro.txt
@@ -1686,18 +1686,19 @@ bara oblică (/), ceea ce îl face potrivit pentru potrivirea în cadrul unei si
 componente a căii. Acesta este comportamentul standard al metacaracterelor, familiar
 din shell globbing.
 
-Asteriscul dublu `**` este mai puternic, se potrivește cu orice secvență de
-caractere, inclusiv separatori de directoare. Acest lucru permite modelelor să se potrivească
-pe mai multe niveluri de directoare. Când `**` apare inserat direct într-un
-model, se poate potrivi cu zero sau mai multe caractere, inclusiv slash-uri între
-textul literal înconjurător.
+Metacaracterul asterisc dublu `**` se potrivește peste separatorii de
+directoare numai atunci când este adiacent unui separator de directoare
+(precedat sau urmat de o bară oblică). În această formă, se potrivește cu
+zero sau mai multe caractere pe mai multe niveluri de directoare. De exemplu,
+`foo/**/bar` se potrivește cu `foo/bar`, `foo/a/bar` și `foo/a/b/bar`;
+`**/build` se potrivește cu `build` și `foo/bar/build`; iar `src/**.js` se
+potrivește cu `src/main.js` și `src/ui/components/main.js`.
+Forma de sine stătătoare `/**/` nu este acceptată ca un model complet.
 
-Cea mai importantă utilizare a lui `**` este în forma specială `/**/`. Aceasta se potrivește cu
-zero sau mai multe niveluri complete de directoare, făcând posibilă potrivirea fișierelor
-la orice adâncime într-un arbore de directoare fără a cunoaște structura exactă a căii.
-De exemplu, modelul `src/**/main.js` se potrivește cu `src/main.js` (sărind
-peste zero directoare), `src/ui/main.js` (sărind peste un director) și
-`src/ui/components/main.js` (sărind peste două directoare).
+Când `**` nu este adiacent unei bare oblice, se comportă ca `*` și nu se
+potrivește cu separatorii de directoare. De exemplu, `**.jpg` se potrivește cu
+`photo.jpg` în directorul curent, dar nu se potrivește cu `dir/photo.jpg`.
+Folosiți `**/*.jpg` în acest scop.
 
 Clasele de caractere care utilizează paranteze pătrate `[]` se potrivesc cu un singur caracter dintr-un
 set sau interval specificat. La fel ca și celelalte modele de un singur caracter, acestea
@@ -1706,8 +1707,8 @@ un semn de exclamare.
 
 Distincția fundamentală de reținut este că `*`, `?` și clasele de caractere
 respectă toate limitele directoarelor și se potrivesc doar în cadrul unei singure
-componente a căii, în timp ce `**` este singurul model care se poate potrivi peste
-separatorii de directoare.
+componente a căii, în timp ce `**` se poate potrivi peste separatorii de directoare
+numai atunci când este adiacent unei bare oblice.
 
 Există patru tipuri diferite de modele:
 
diff --git a/doc/snapraid-ru.1 b/doc/snapraid-ru.1
index 9269d29a..747e889a 100644
--- a/doc/snapraid-ru.1
+++ b/doc/snapraid-ru.1
@@ -1973,18 +1973,19 @@ SnapRAID управляет тремя конкретными снимками,
 компонента пути. Это стандартное поведение подстановочных знаков, знакомое
 по оболочке (shell).
 .PP
-Двойная звездочка \`**\` более мощная, она соответствует любой последовательности
-символов, включая разделители каталогов. Это позволяет шаблонам соответствовать
-нескольким уровням каталогов. Когда \`**\` появляется непосредственно в
-шаблоне, она может соответствовать нулю или более символам, включая косые черты между
-окружающим буквальным текстом.
+Символ подстановки двойная звездочка \`**\` сопоставляется через разделители
+каталогов только тогда, когда он примыкает к разделителю каталогов (перед ним
+или после него стоит косая черта). В этой форме он соответствует нулю или
+более символам на нескольких уровнях каталогов. Например, \`foo/**/bar\`
+соответствует \`foo/bar\`, \`foo/a/bar\` и \`foo/a/b/bar\`; \`**/build\` соответствует
+\`build\` и \`foo/bar/build\`; а \`src/**.js\` соответствует \`src/main.js\` и
+\`src/ui/components/main.js\`.
+Автономная форма \`/**/\` не принимается в качестве полного шаблона.
 .PP
-Наиболее важным использованием \`**\` является специальная форма \`/**/\`. Она соответствует
-нулю или более полным уровням каталогов, что позволяет сопоставлять файлы
-на любой глубине в дереве каталогов, не зная точной структуры пути.
-Например, шаблон \`src/**/main.js\` соответствует \`src/main.js\` (пропуск
-ноля каталогов), \`src/ui/main.js\` (пропуск одного каталога) и
-\`src/ui/components/main.js\` (пропуск двух каталогов).
+Когда \`**\` не примыкает к косой черте, он ведет себя как \`*\` и не
+соответствует разделителям каталогов. Например, \`**.jpg\` соответствует
+\`photo.jpg\` в текущем каталоге, но не соответствует \`dir/photo.jpg\`. Для этой
+цели используйте \`**/*.jpg\`.
 .PP
 Классы символов с использованием квадратных скобок \`[]\` соответствуют одному символу из
 заданного набора или диапазона. Как и другие односимвольные шаблоны, они
@@ -1993,8 +1994,8 @@ SnapRAID управляет тремя конкретными снимками,
 .PP
 Фундаментальное различие, которое следует помнить, заключается в том, что \`*\`, \`?\` и классы
 символов соблюдают границы каталогов и соответствуют только внутри одного
-компонента пути, в то время как \`**\` — единственный шаблон, который может соответствовать
-через разделители каталогов.
+компонента пути, в то время как \`**\` может соответствовать через разделители
+каталогов только тогда, когда примыкает к косой черте.
 .PP
 Существует четыре различных типа шаблонов:
 .TP
diff --git a/doc/snapraid-ru.d b/doc/snapraid-ru.d
index 8abf8cf8..3f27c5e0 100644
--- a/doc/snapraid-ru.d
+++ b/doc/snapraid-ru.d
@@ -1580,18 +1580,19 @@ Name{number}
 	компонента пути. Это стандартное поведение подстановочных знаков, знакомое
 	по оболочке (shell).
 
-	Двойная звездочка `**` более мощная, она соответствует любой последовательности
-	символов, включая разделители каталогов. Это позволяет шаблонам соответствовать
-	нескольким уровням каталогов. Когда `**` появляется непосредственно в
-	шаблоне, она может соответствовать нулю или более символам, включая косые черты между
-	окружающим буквальным текстом.
+	Символ подстановки двойная звездочка `**` сопоставляется через разделители
+	каталогов только тогда, когда он примыкает к разделителю каталогов (перед ним
+	или после него стоит косая черта). В этой форме он соответствует нулю или
+	более символам на нескольких уровнях каталогов. Например, `foo/**/bar`
+	соответствует `foo/bar`, `foo/a/bar` и `foo/a/b/bar`; `**/build` соответствует
+	`build` и `foo/bar/build`; а `src/**.js` соответствует `src/main.js` и
+	`src/ui/components/main.js`.
+	Автономная форма `/**/` не принимается в качестве полного шаблона.
 
-	Наиболее важным использованием `**` является специальная форма `/**/`. Она соответствует
-	нулю или более полным уровням каталогов, что позволяет сопоставлять файлы
-	на любой глубине в дереве каталогов, не зная точной структуры пути.
-	Например, шаблон `src/**/main.js` соответствует `src/main.js` (пропуск
-	ноля каталогов), `src/ui/main.js` (пропуск одного каталога) и
-	`src/ui/components/main.js` (пропуск двух каталогов).
+	Когда `**` не примыкает к косой черте, он ведет себя как `*` и не
+	соответствует разделителям каталогов. Например, `**.jpg` соответствует
+	`photo.jpg` в текущем каталоге, но не соответствует `dir/photo.jpg`. Для этой
+	цели используйте `**/*.jpg`.
 
 	Классы символов с использованием квадратных скобок `[]` соответствуют одному символу из
 	заданного набора или диапазона. Как и другие односимвольные шаблоны, они
@@ -1600,8 +1601,8 @@ Name{number}
 
 	Фундаментальное различие, которое следует помнить, заключается в том, что `*`, `?` и классы
 	символов соблюдают границы каталогов и соответствуют только внутри одного
-	компонента пути, в то время как `**` — единственный шаблон, который может соответствовать
-	через разделители каталогов.
+	компонента пути, в то время как `**` может соответствовать через разделители
+	каталогов только тогда, когда примыкает к косой черте.
 
 	Существует четыре различных типа шаблонов:
 
diff --git a/doc/snapraid-ru.txt b/doc/snapraid-ru.txt
index a4384be5..fa140dee 100644
--- a/doc/snapraid-ru.txt
+++ b/doc/snapraid-ru.txt
@@ -1693,18 +1693,19 @@ SnapRAID управляет тремя конкретными снимками,
 компонента пути. Это стандартное поведение подстановочных знаков, знакомое
 по оболочке (shell).
 
-Двойная звездочка `**` более мощная, она соответствует любой последовательности
-символов, включая разделители каталогов. Это позволяет шаблонам соответствовать
-нескольким уровням каталогов. Когда `**` появляется непосредственно в
-шаблоне, она может соответствовать нулю или более символам, включая косые черты между
-окружающим буквальным текстом.
+Символ подстановки двойная звездочка `**` сопоставляется через разделители
+каталогов только тогда, когда он примыкает к разделителю каталогов (перед ним
+или после него стоит косая черта). В этой форме он соответствует нулю или
+более символам на нескольких уровнях каталогов. Например, `foo/**/bar`
+соответствует `foo/bar`, `foo/a/bar` и `foo/a/b/bar`; `**/build` соответствует
+`build` и `foo/bar/build`; а `src/**.js` соответствует `src/main.js` и
+`src/ui/components/main.js`.
+Автономная форма `/**/` не принимается в качестве полного шаблона.
 
-Наиболее важным использованием `**` является специальная форма `/**/`. Она соответствует
-нулю или более полным уровням каталогов, что позволяет сопоставлять файлы
-на любой глубине в дереве каталогов, не зная точной структуры пути.
-Например, шаблон `src/**/main.js` соответствует `src/main.js` (пропуск
-ноля каталогов), `src/ui/main.js` (пропуск одного каталога) и
-`src/ui/components/main.js` (пропуск двух каталогов).
+Когда `**` не примыкает к косой черте, он ведет себя как `*` и не
+соответствует разделителям каталогов. Например, `**.jpg` соответствует
+`photo.jpg` в текущем каталоге, но не соответствует `dir/photo.jpg`. Для этой
+цели используйте `**/*.jpg`.
 
 Классы символов с использованием квадратных скобок `[]` соответствуют одному символу из
 заданного набора или диапазона. Как и другие односимвольные шаблоны, они
@@ -1713,8 +1714,8 @@ SnapRAID управляет тремя конкретными снимками,
 
 Фундаментальное различие, которое следует помнить, заключается в том, что `*`, `?` и классы
 символов соблюдают границы каталогов и соответствуют только внутри одного
-компонента пути, в то время как `**` — единственный шаблон, который может соответствовать
-через разделители каталогов.
+компонента пути, в то время как `**` может соответствовать через разделители
+каталогов только тогда, когда примыкает к косой черте.
 
 Существует четыре различных типа шаблонов:
 
diff --git a/doc/snapraid-sv.1 b/doc/snapraid-sv.1
index d9990953..664c6e1c 100644
--- a/doc/snapraid-sv.1
+++ b/doc/snapraid-sv.1
@@ -1971,18 +1971,17 @@ snedstrecket, vilket gör den lämplig för matchning inom en enskild
 sökvägskomponent. Detta är det standardbeteende för jokertecken som är
 bekant från skal\-globbing.
 .PP
-Den dubbla stjärnan \`**\` är mer kraftfull; den matchar valfri teckensekvens
-inklusive katalogavgränsare. Detta gör att mönster kan matcha över
-flera katalognivåer. När \`**\` förekommer direkt i ett mönster kan det
-matcha noll eller fler tecken inklusive snedstreck mellan den
-omkringliggande bokstavliga texten.
+Jokertecknet med dubbelstjärna \`**\` matchar över katalogavgränsare endast när
+det gränsar till en katalogavgränsare (föregås eller efterföljs av ett
+snedstreck). I denna form matchar det noll eller fler tecken över flera
+katalognivåer. Till exempel matchar \`foo/**/bar\` sökvägarna \`foo/bar\`,
+\`foo/a/bar\` och \`foo/a/b/bar\`; \`**/build\` matchar \`build\` och \`foo/bar/build\`;
+och \`src/**.js\` matchar \`src/main.js\` och \`src/ui/components/main.js\`.
+Den fristående formen \`/**/\` accepteras inte som ett fullständigt mönster.
 .PP
-Den viktigaste användningen av \`**\` är i den speciella formen \`/**/\`. Detta matchar
-noll eller flera kompletta katalognivåer, vilket gör det möjligt att matcha filer
-på valfritt djup i ett katalogträd utan att känna till den exakta sökvägsstrukturen.
-Till exempel matchar mönstret \`src/**/main.js\` filerna \`src/main.js\` (hoppar över
-noll kataloger), \`src/ui/main.js\` (hoppar över en katalog) och
-\`src/ui/components/main.js\` (hoppar över två kataloger).
+När \`**\` inte gränsar till ett snedstreck beter det sig som \`*\` och matchar
+inte katalogavgränsare. Till exempel matchar \`**.jpg\` filen \`photo.jpg\` i den
+aktuella katalogen, men inte \`dir/photo.jpg\`. Använd \`**/*.jpg\` för detta ändamål.
 .PP
 Teckenklasser som använder hakparenteser \`[]\` matchar ett enskilt tecken från en
 angiven uppsättning eller ett intervall. Precis som de andra mönstren för enskilda
@@ -1991,8 +1990,8 @@ negering med ett utropstecken.
 .PP
 Den grundläggande skillnaden att komma ihåg är att \`*\`, \`?\` och teckenklasser
 alla respekterar kataloggränser och endast matchar inom en enskild
-sökvägskomponent, medan \`**\` är det enda mönstret som kan matcha över
-katalogavgränsare.
+sökvägskomponent, medan \`**\` endast kan matcha över katalogavgränsare när det
+gränsar till ett snedstreck.
 .PP
 Det finns fyra olika typer av mönster:
 .TP
diff --git a/doc/snapraid-sv.d b/doc/snapraid-sv.d
index d0bb3864..0d7c3655 100644
--- a/doc/snapraid-sv.d
+++ b/doc/snapraid-sv.d
@@ -1576,18 +1576,17 @@ Mönster (Pattern)
 	sökvägskomponent. Detta är det standardbeteende för jokertecken som är
 	bekant från skal-globbing.
 
-	Den dubbla stjärnan `**` är mer kraftfull; den matchar valfri teckensekvens
-	inklusive katalogavgränsare. Detta gör att mönster kan matcha över
-	flera katalognivåer. När `**` förekommer direkt i ett mönster kan det
-	matcha noll eller fler tecken inklusive snedstreck mellan den
-	omkringliggande bokstavliga texten.
+	Jokertecknet med dubbelstjärna `**` matchar över katalogavgränsare endast när
+	det gränsar till en katalogavgränsare (föregås eller efterföljs av ett
+	snedstreck). I denna form matchar det noll eller fler tecken över flera
+	katalognivåer. Till exempel matchar `foo/**/bar` sökvägarna `foo/bar`,
+	`foo/a/bar` och `foo/a/b/bar`; `**/build` matchar `build` och `foo/bar/build`;
+	och `src/**.js` matchar `src/main.js` och `src/ui/components/main.js`.
+	Den fristående formen `/**/` accepteras inte som ett fullständigt mönster.
 
-	Den viktigaste användningen av `**` är i den speciella formen `/**/`. Detta matchar
-	noll eller flera kompletta katalognivåer, vilket gör det möjligt att matcha filer
-	på valfritt djup i ett katalogträd utan att känna till den exakta sökvägsstrukturen.
-	Till exempel matchar mönstret `src/**/main.js` filerna `src/main.js` (hoppar över
-	noll kataloger), `src/ui/main.js` (hoppar över en katalog) och
-	`src/ui/components/main.js` (hoppar över två kataloger).
+	När `**` inte gränsar till ett snedstreck beter det sig som `*` och matchar
+	inte katalogavgränsare. Till exempel matchar `**.jpg` filen `photo.jpg` i den
+	aktuella katalogen, men inte `dir/photo.jpg`. Använd `**/*.jpg` för detta ändamål.
 
 	Teckenklasser som använder hakparenteser `[]` matchar ett enskilt tecken från en
 	angiven uppsättning eller ett intervall. Precis som de andra mönstren för enskilda
@@ -1596,8 +1595,8 @@ Mönster (Pattern)
 
 	Den grundläggande skillnaden att komma ihåg är att `*`, `?` och teckenklasser
 	alla respekterar kataloggränser och endast matchar inom en enskild
-	sökvägskomponent, medan `**` är det enda mönstret som kan matcha över
-	katalogavgränsare.
+	sökvägskomponent, medan `**` endast kan matcha över katalogavgränsare när det
+	gränsar till ett snedstreck.
 
 	Det finns fyra olika typer av mönster:
 
diff --git a/doc/snapraid-sv.txt b/doc/snapraid-sv.txt
index ed0e7036..a3ba946a 100644
--- a/doc/snapraid-sv.txt
+++ b/doc/snapraid-sv.txt
@@ -1689,18 +1689,17 @@ snedstrecket, vilket gör den lämplig för matchning inom en enskild
 sökvägskomponent. Detta är det standardbeteende för jokertecken som är
 bekant från skal-globbing.
 
-Den dubbla stjärnan `**` är mer kraftfull; den matchar valfri teckensekvens
-inklusive katalogavgränsare. Detta gör att mönster kan matcha över
-flera katalognivåer. När `**` förekommer direkt i ett mönster kan det
-matcha noll eller fler tecken inklusive snedstreck mellan den
-omkringliggande bokstavliga texten.
+Jokertecknet med dubbelstjärna `**` matchar över katalogavgränsare endast när
+det gränsar till en katalogavgränsare (föregås eller efterföljs av ett
+snedstreck). I denna form matchar det noll eller fler tecken över flera
+katalognivåer. Till exempel matchar `foo/**/bar` sökvägarna `foo/bar`,
+`foo/a/bar` och `foo/a/b/bar`; `**/build` matchar `build` och `foo/bar/build`;
+och `src/**.js` matchar `src/main.js` och `src/ui/components/main.js`.
+Den fristående formen `/**/` accepteras inte som ett fullständigt mönster.
 
-Den viktigaste användningen av `**` är i den speciella formen `/**/`. Detta matchar
-noll eller flera kompletta katalognivåer, vilket gör det möjligt att matcha filer
-på valfritt djup i ett katalogträd utan att känna till den exakta sökvägsstrukturen.
-Till exempel matchar mönstret `src/**/main.js` filerna `src/main.js` (hoppar över
-noll kataloger), `src/ui/main.js` (hoppar över en katalog) och
-`src/ui/components/main.js` (hoppar över två kataloger).
+När `**` inte gränsar till ett snedstreck beter det sig som `*` och matchar
+inte katalogavgränsare. Till exempel matchar `**.jpg` filen `photo.jpg` i den
+aktuella katalogen, men inte `dir/photo.jpg`. Använd `**/*.jpg` för detta ändamål.
 
 Teckenklasser som använder hakparenteser `[]` matchar ett enskilt tecken från en
 angiven uppsättning eller ett intervall. Precis som de andra mönstren för enskilda
@@ -1709,8 +1708,8 @@ negering med ett utropstecken.
 
 Den grundläggande skillnaden att komma ihåg är att `*`, `?` och teckenklasser
 alla respekterar kataloggränser och endast matchar inom en enskild
-sökvägskomponent, medan `**` är det enda mönstret som kan matcha över
-katalogavgränsare.
+sökvägskomponent, medan `**` endast kan matcha över katalogavgränsare när det
+gränsar till ett snedstreck.
 
 Det finns fyra olika typer av mönster:
 
diff --git a/doc/snapraid-uk.1 b/doc/snapraid-uk.1
index 602aa050..1f9898dc 100644
--- a/doc/snapraid-uk.1
+++ b/doc/snapraid-uk.1
@@ -2143,18 +2143,19 @@ SnapRAID керує трьома конкретними знімками, \`stab
 компонента шляху. Це стандартна поведінка підстановочних знаків, знайома
 з командної оболонки (shell globbing).
 .PP
-Подвійна зірочка \`**\` є потужнішою, вона відповідає будь\-якій послідовності
-символів, включаючи роздільники каталогів. Це дозволяє шаблонам відповідати
-кільком рівням каталогів. Коли \`**\` з\'являється безпосередньо в шаблоні,
-вона може відповідати нулю або більше символам, включаючи косі риски між
-оточуючим літеральним текстом.
+Символ підстановки подвійна зірочка \`**\` зіставляється через роздільники
+каталогів лише тоді, коли він прилягає до роздільника каталогів (перед ним або
+після нього стоїть скісна риска). У цій формі він відповідає нулю або більше
+символам на кількох рівнях каталогів. Наприклад, \`foo/**/bar\` відповідає
+\`foo/bar\`, \`foo/a/bar\` та \`foo/a/b/bar\`; \`**/build\` відповідає \`build\` та
+\`foo/bar/build\`; а \`src/**.js\` відповідає \`src/main.js\` та
+\`src/ui/components/main.js\`.
+Окрема форма \`/**/\` не приймається як повний шаблон.
 .PP
-Найважливішим використанням \`**\` є спеціальна форма \`/**/\`. Вона відповідає
-нулю або більше повним рівням каталогів, що дозволяє зіставляти файли
-на будь\-якій глибині в дереві каталогів, не знаючи точної структури шляху.
-Наприклад, шаблон \`src/**/main.js\` відповідає \`src/main.js\` (пропуск
-нуля каталогів), \`src/ui/main.js\` (пропуск одного каталогу) та
-\`src/ui/components/main.js\` (пропуск двох каталогів).
+Коли \`**\` не прилягає до скісної риски, він поводиться як \`*\` і не відповідає
+роздільникам каталогів. Наприклад, \`**.jpg\` відповідає \`photo.jpg\` у поточному
+каталозі, але не відповідає \`dir/photo.jpg\`. Для цієї мети використовуйте
+\`**/*.jpg\`.
 .PP
 Класи символів із використанням квадратних дужок \`[]\` відповідають одному символу з
 визначеного набору або діапазону. Як і інші односимвольні шаблони, вони
@@ -2163,8 +2164,8 @@ SnapRAID керує трьома конкретними знімками, \`stab
 .PP
 Фундаментальна відмінність, яку слід пам\'ятати, полягає в тому, що \`*\`, \`?\` та класи символів
 усі дотримуються меж каталогів і відповідають лише в межах одного компонента
-шляху, тоді як \`**\` — єдиний шаблон, який може відповідати через роздільники
-каталогів.
+шляху, тоді як \`**\` може відповідати через роздільники каталогів лише тоді,
+коли прилягає до скісної риски.
 .PP
 Існує чотири різні типи шаблонів:
 .TP
diff --git a/doc/snapraid-uk.d b/doc/snapraid-uk.d
index 83a2b76b..887ba8eb 100644
--- a/doc/snapraid-uk.d
+++ b/doc/snapraid-uk.d
@@ -1739,18 +1739,19 @@ Name{number}
 	компонента шляху. Це стандартна поведінка підстановочних знаків, знайома
 	з командної оболонки (shell globbing).
 
-	Подвійна зірочка `**` є потужнішою, вона відповідає будь-якій послідовності
-	символів, включаючи роздільники каталогів. Це дозволяє шаблонам відповідати
-	кільком рівням каталогів. Коли `**` з'являється безпосередньо в шаблоні,
-	вона може відповідати нулю або більше символам, включаючи косі риски між
-	оточуючим літеральним текстом.
+	Символ підстановки подвійна зірочка `**` зіставляється через роздільники
+	каталогів лише тоді, коли він прилягає до роздільника каталогів (перед ним або
+	після нього стоїть скісна риска). У цій формі він відповідає нулю або більше
+	символам на кількох рівнях каталогів. Наприклад, `foo/**/bar` відповідає
+	`foo/bar`, `foo/a/bar` та `foo/a/b/bar`; `**/build` відповідає `build` та
+	`foo/bar/build`; а `src/**.js` відповідає `src/main.js` та
+	`src/ui/components/main.js`.
+	Окрема форма `/**/` не приймається як повний шаблон.
 
-	Найважливішим використанням `**` є спеціальна форма `/**/`. Вона відповідає
-	нулю або більше повним рівням каталогів, що дозволяє зіставляти файли
-	на будь-якій глибині в дереві каталогів, не знаючи точної структури шляху.
-	Наприклад, шаблон `src/**/main.js` відповідає `src/main.js` (пропуск
-	нуля каталогів), `src/ui/main.js` (пропуск одного каталогу) та
-	`src/ui/components/main.js` (пропуск двох каталогів).
+	Коли `**` не прилягає до скісної риски, він поводиться як `*` і не відповідає
+	роздільникам каталогів. Наприклад, `**.jpg` відповідає `photo.jpg` у поточному
+	каталозі, але не відповідає `dir/photo.jpg`. Для цієї мети використовуйте
+	`**/*.jpg`.
 
 	Класи символів із використанням квадратних дужок `[]` відповідають одному символу з
 	визначеного набору або діапазону. Як і інші односимвольні шаблони, вони
@@ -1759,8 +1760,8 @@ Name{number}
 
 	Фундаментальна відмінність, яку слід пам'ятати, полягає в тому, що `*`, `?` та класи символів
 	усі дотримуються меж каталогів і відповідають лише в межах одного компонента
-	шляху, тоді як `**` — єдиний шаблон, який може відповідати через роздільники
-	каталогів.
+	шляху, тоді як `**` може відповідати через роздільники каталогів лише тоді,
+	коли прилягає до скісної риски.
 
 	Існує чотири різні типи шаблонів:
 
diff --git a/doc/snapraid-uk.txt b/doc/snapraid-uk.txt
index 060b643f..23c67227 100644
--- a/doc/snapraid-uk.txt
+++ b/doc/snapraid-uk.txt
@@ -1852,18 +1852,19 @@ SnapRAID керує трьома конкретними знімками, `stabl
 компонента шляху. Це стандартна поведінка підстановочних знаків, знайома
 з командної оболонки (shell globbing).
 
-Подвійна зірочка `**` є потужнішою, вона відповідає будь-якій послідовності
-символів, включаючи роздільники каталогів. Це дозволяє шаблонам відповідати
-кільком рівням каталогів. Коли `**` з'являється безпосередньо в шаблоні,
-вона може відповідати нулю або більше символам, включаючи косі риски між
-оточуючим літеральним текстом.
+Символ підстановки подвійна зірочка `**` зіставляється через роздільники
+каталогів лише тоді, коли він прилягає до роздільника каталогів (перед ним або
+після нього стоїть скісна риска). У цій формі він відповідає нулю або більше
+символам на кількох рівнях каталогів. Наприклад, `foo/**/bar` відповідає
+`foo/bar`, `foo/a/bar` та `foo/a/b/bar`; `**/build` відповідає `build` та
+`foo/bar/build`; а `src/**.js` відповідає `src/main.js` та
+`src/ui/components/main.js`.
+Окрема форма `/**/` не приймається як повний шаблон.
 
-Найважливішим використанням `**` є спеціальна форма `/**/`. Вона відповідає
-нулю або більше повним рівням каталогів, що дозволяє зіставляти файли
-на будь-якій глибині в дереві каталогів, не знаючи точної структури шляху.
-Наприклад, шаблон `src/**/main.js` відповідає `src/main.js` (пропуск
-нуля каталогів), `src/ui/main.js` (пропуск одного каталогу) та
-`src/ui/components/main.js` (пропуск двох каталогів).
+Коли `**` не прилягає до скісної риски, він поводиться як `*` і не відповідає
+роздільникам каталогів. Наприклад, `**.jpg` відповідає `photo.jpg` у поточному
+каталозі, але не відповідає `dir/photo.jpg`. Для цієї мети використовуйте
+`**/*.jpg`.
 
 Класи символів із використанням квадратних дужок `[]` відповідають одному символу з
 визначеного набору або діапазону. Як і інші односимвольні шаблони, вони
@@ -1872,8 +1873,8 @@ SnapRAID керує трьома конкретними знімками, `stabl
 
 Фундаментальна відмінність, яку слід пам'ятати, полягає в тому, що `*`, `?` та класи символів
 усі дотримуються меж каталогів і відповідають лише в межах одного компонента
-шляху, тоді як `**` — єдиний шаблон, який може відповідати через роздільники
-каталогів.
+шляху, тоді як `**` може відповідати через роздільники каталогів лише тоді,
+коли прилягає до скісної риски.
 
 Існує чотири різні типи шаблонів:
 
diff --git a/doc/snapraid-zh.1 b/doc/snapraid-zh.1
index 06394666..b291c1a8 100644
--- a/doc/snapraid-zh.1
+++ b/doc/snapraid-zh.1
@@ -1765,22 +1765,24 @@ SnapRAID 在每个数据子卷根目录下的隐藏目录中管理三个特定
 它在正斜杠处停止，因此适用于匹配单个路径组件内的内容。
 这是 Shell 通配符中常见的标准行为。
 .PP
-双星号 \`**\` 功能更强大，它可以匹配任何字符序列，包括目录分隔符。
-这允许模式匹配跨越多个目录层级。当 \`**\` 直接嵌入在模式中时，
-它可以匹配零个或多个字符，包括周围文字文本之间的斜杠。
+双星号通配符 \`**\` 仅在与目录分隔符相邻时（前面或后面有斜杠）才能跨越
+目录分隔符进行匹配。在此形式下，它可以跨越多个目录层级匹配零个或多个字符。
+例如，\`foo/**/bar\` 匹配 \`foo/bar\`、\`foo/a/bar\` 和 \`foo/a/b/bar\`；
+\`**/build\` 匹配 \`build\` 和 \`foo/bar/build\`；\`src/**.js\` 匹配 \`src/main.js\`
+和 \`src/ui/components/main.js\`。
+单独的形式 \`/**/\` 不被接受为完整的模式。
 .PP
-\`**\` 最重要的用法是特殊形式 \`/**/\`。它可以匹配零个或多个完整的目录层级，
-从而可以在不知道确切路径结构的情况下，匹配目录树中任何深度的文件。
-例如，模式 \`src/**/main.js\` 匹配 \`src/main.js\`（跳过零个目录）、
-\`src/ui/main.js\`（跳过一个目录）以及 \`src/ui/components/main.js\`
-（跳过两个目录）。
+当 \`**\` 不与斜杠相邻时，其行为类似于 \`*\`，不会匹配目录分隔符。例如，
+\`**.jpg\` 匹配当前目录中的 \`photo.jpg\`，但不会匹配 \`dir/photo.jpg\`。
+如需匹配子目录中的文件，请使用 \`**/*.jpg\`。
 .PP
 使用方括号 \`[]\` 的字符类匹配指定集合或范围内的单个字符。
 与其他单字符模式一样，它们不匹配目录分隔符。字符类支持使用
 感叹号进行范围指定和否定。
 .PP
 需要记住的根本区别是，\`*\`、\`?\` 和字符类都遵循目录边界，
-并且仅在单个路径组件内匹配，而 \`**\` 是唯一可以跨越目录分隔符匹配的模式。
+并且仅在单个路径组件内匹配，而 \`**\` 仅在与斜杠相邻时才能跨越
+目录分隔符进行匹配。
 .PP
 有四种不同类型的模式：
 .TP
diff --git a/doc/snapraid-zh.d b/doc/snapraid-zh.d
index be7a6121..bbd324a3 100644
--- a/doc/snapraid-zh.d
+++ b/doc/snapraid-zh.d
@@ -1370,22 +1370,24 @@ Name{number}
 	它在正斜杠处停止，因此适用于匹配单个路径组件内的内容。
 	这是 Shell 通配符中常见的标准行为。
 
-	双星号 `**` 功能更强大，它可以匹配任何字符序列，包括目录分隔符。
-	这允许模式匹配跨越多个目录层级。当 `**` 直接嵌入在模式中时，
-	它可以匹配零个或多个字符，包括周围文字文本之间的斜杠。
+	双星号通配符 `**` 仅在与目录分隔符相邻时（前面或后面有斜杠）才能跨越
+	目录分隔符进行匹配。在此形式下，它可以跨越多个目录层级匹配零个或多个字符。
+	例如，`foo/**/bar` 匹配 `foo/bar`、`foo/a/bar` 和 `foo/a/b/bar`；
+	`**/build` 匹配 `build` 和 `foo/bar/build`；`src/**.js` 匹配 `src/main.js`
+	和 `src/ui/components/main.js`。
+	单独的形式 `/**/` 不被接受为完整的模式。
 
-	`**` 最重要的用法是特殊形式 `/**/`。它可以匹配零个或多个完整的目录层级，
-	从而可以在不知道确切路径结构的情况下，匹配目录树中任何深度的文件。
-	例如，模式 `src/**/main.js` 匹配 `src/main.js`（跳过零个目录）、
-	`src/ui/main.js`（跳过一个目录）以及 `src/ui/components/main.js`
-	（跳过两个目录）。
+	当 `**` 不与斜杠相邻时，其行为类似于 `*`，不会匹配目录分隔符。例如，
+	`**.jpg` 匹配当前目录中的 `photo.jpg`，但不会匹配 `dir/photo.jpg`。
+	如需匹配子目录中的文件，请使用 `**/*.jpg`。
 
 	使用方括号 `[]` 的字符类匹配指定集合或范围内的单个字符。
 	与其他单字符模式一样，它们不匹配目录分隔符。字符类支持使用
 	感叹号进行范围指定和否定。
 
 	需要记住的根本区别是，`*`、`?` 和字符类都遵循目录边界，
-	并且仅在单个路径组件内匹配，而 `**` 是唯一可以跨越目录分隔符匹配的模式。
+	并且仅在单个路径组件内匹配，而 `**` 仅在与斜杠相邻时才能跨越
+	目录分隔符进行匹配。
 
 	有四种不同类型的模式：
 
diff --git a/doc/snapraid-zh.txt b/doc/snapraid-zh.txt
index 6d306cd5..fe978dcf 100644
--- a/doc/snapraid-zh.txt
+++ b/doc/snapraid-zh.txt
@@ -1483,22 +1483,24 @@ SnapRAID 在每个数据子卷根目录下的隐藏目录中管理三个特定
 它在正斜杠处停止，因此适用于匹配单个路径组件内的内容。
 这是 Shell 通配符中常见的标准行为。
 
-双星号 `**` 功能更强大，它可以匹配任何字符序列，包括目录分隔符。
-这允许模式匹配跨越多个目录层级。当 `**` 直接嵌入在模式中时，
-它可以匹配零个或多个字符，包括周围文字文本之间的斜杠。
+双星号通配符 `**` 仅在与目录分隔符相邻时（前面或后面有斜杠）才能跨越
+目录分隔符进行匹配。在此形式下，它可以跨越多个目录层级匹配零个或多个字符。
+例如，`foo/**/bar` 匹配 `foo/bar`、`foo/a/bar` 和 `foo/a/b/bar`；
+`**/build` 匹配 `build` 和 `foo/bar/build`；`src/**.js` 匹配 `src/main.js`
+和 `src/ui/components/main.js`。
+单独的形式 `/**/` 不被接受为完整的模式。
 
-`**` 最重要的用法是特殊形式 `/**/`。它可以匹配零个或多个完整的目录层级，
-从而可以在不知道确切路径结构的情况下，匹配目录树中任何深度的文件。
-例如，模式 `src/**/main.js` 匹配 `src/main.js`（跳过零个目录）、
-`src/ui/main.js`（跳过一个目录）以及 `src/ui/components/main.js`
-（跳过两个目录）。
+当 `**` 不与斜杠相邻时，其行为类似于 `*`，不会匹配目录分隔符。例如，
+`**.jpg` 匹配当前目录中的 `photo.jpg`，但不会匹配 `dir/photo.jpg`。
+如需匹配子目录中的文件，请使用 `**/*.jpg`。
 
 使用方括号 `[]` 的字符类匹配指定集合或范围内的单个字符。
 与其他单字符模式一样，它们不匹配目录分隔符。字符类支持使用
 感叹号进行范围指定和否定。
 
 需要记住的根本区别是，`*`、`?` 和字符类都遵循目录边界，
-并且仅在单个路径组件内匹配，而 `**` 是唯一可以跨越目录分隔符匹配的模式。
+并且仅在单个路径组件内匹配，而 `**` 仅在与斜杠相邻时才能跨越
+目录分隔符进行匹配。
 
 有四种不同类型的模式：
 
diff --git a/doc/snapraid.1 b/doc/snapraid.1
index 4cf2293a..fffc8192 100644
--- a/doc/snapraid.1
+++ b/doc/snapraid.1
@@ -1976,20 +1976,19 @@ forward slash, making it suitable for matching within a single path
 component. This is the standard wildcard behavior familiar from shell
 globbing.
 .PP
-The double star \`**\` is more powerful, it matches any sequence of
-characters including directory separators. This allows patterns to match
-across multiple directory levels. When \`**\` appears embedded directly in
-a pattern, it can match zero or more characters including slashes between
-the surrounding literal text.
-.PP
-The most important use of \`**\` is in the special form \`/**/\`. This matches
-zero or more complete directory levels, making it possible to match files
-at any depth in a directory tree without knowing the exact path structure.
-For example, the pattern \`src/**/main.js\` matches \`src/main.js\` (skipping
-zero directories), \`src/ui/main.js\` (skipping one directory), and
-\`src/ui/components/main.js\` (skipping two directories).
+The double star \`**\` wildcard matches across directory separators only
+when it is adjacent to a directory separator (preceded or followed by a
+slash). In this form, it matches zero or more characters across directory
+levels. For example, \`foo/**/bar\` matches \`foo/bar\`, \`foo/a/bar\`, and
+\`foo/a/b/bar\`; \`**/build\` matches \`build\` and \`foo/bar/build\`; and
+\`src/**.js\` matches \`src/main.js\` and \`src/ui/components/main.js\`.
 The standalone form \`/**/\` is not accepted as a complete pattern.
 .PP
+When \`**\` is not adjacent to a slash, it behaves like \`*\` and does not
+match directory separators. For example, \`**.jpg\` matches \`photo.jpg\`
+within the current directory, but does not match \`dir/photo.jpg\`. Use
+\`**/*.jpg\` for that purpose.
+.PP
 Character classes using square brackets match a single character from a
 specified set or range. Like the other single character patterns, they do
 not match directory separators. Classes support ranges and negation using
@@ -1997,8 +1996,8 @@ an exclamation mark.
 .PP
 The fundamental distinction to remember is that \`*\`, \`?\`, and character
 classes all respect directory boundaries and only match within a single path
-component, while \`**\` is the only pattern that can match across directory
-separators.
+component, while \`**\` can match across directory separators only when
+adjacent to a slash.
 .PP
 There are four different types of patterns:
 .TP
diff --git a/doc/snapraid.d b/doc/snapraid.d
index 42a7af60..00b92345 100644
--- a/doc/snapraid.d
+++ b/doc/snapraid.d
@@ -1581,20 +1581,19 @@ Pattern
 	component. This is the standard wildcard behavior familiar from shell
 	globbing.
 
-	The double star `**` is more powerful, it matches any sequence of
-	characters including directory separators. This allows patterns to match
-	across multiple directory levels. When `**` appears embedded directly in
-	a pattern, it can match zero or more characters including slashes between
-	the surrounding literal text.
-
-	The most important use of `**` is in the special form `/**/`. This matches
-	zero or more complete directory levels, making it possible to match files
-	at any depth in a directory tree without knowing the exact path structure.
-	For example, the pattern `src/**/main.js` matches `src/main.js` (skipping
-	zero directories), `src/ui/main.js` (skipping one directory), and
-	`src/ui/components/main.js` (skipping two directories).
+	The double star `**` wildcard matches across directory separators only
+	when it is adjacent to a directory separator (preceded or followed by a
+	slash). In this form, it matches zero or more characters across directory
+	levels. For example, `foo/**/bar` matches `foo/bar`, `foo/a/bar`, and
+	`foo/a/b/bar`; `**/build` matches `build` and `foo/bar/build`; and
+	`src/**.js` matches `src/main.js` and `src/ui/components/main.js`.
 	The standalone form `/**/` is not accepted as a complete pattern.
 
+	When `**` is not adjacent to a slash, it behaves like `*` and does not
+	match directory separators. For example, `**.jpg` matches `photo.jpg`
+	within the current directory, but does not match `dir/photo.jpg`. Use
+	`**/*.jpg` for that purpose.
+
 	Character classes using square brackets match a single character from a
 	specified set or range. Like the other single character patterns, they do
 	not match directory separators. Classes support ranges and negation using
@@ -1602,8 +1601,8 @@ Pattern
 
 	The fundamental distinction to remember is that `*`, `?`, and character
 	classes all respect directory boundaries and only match within a single path
-	component, while `**` is the only pattern that can match across directory
-	separators.
+	component, while `**` can match across directory separators only when
+	adjacent to a slash.
 
 	There are four different types of patterns:
 
diff --git a/doc/snapraid.txt b/doc/snapraid.txt
index 2073128a..e5b63aac 100644
--- a/doc/snapraid.txt
+++ b/doc/snapraid.txt
@@ -1694,20 +1694,19 @@ forward slash, making it suitable for matching within a single path
 component. This is the standard wildcard behavior familiar from shell
 globbing.
 
-The double star `**` is more powerful, it matches any sequence of
-characters including directory separators. This allows patterns to match
-across multiple directory levels. When `**` appears embedded directly in
-a pattern, it can match zero or more characters including slashes between
-the surrounding literal text.
-
-The most important use of `**` is in the special form `/**/`. This matches
-zero or more complete directory levels, making it possible to match files
-at any depth in a directory tree without knowing the exact path structure.
-For example, the pattern `src/**/main.js` matches `src/main.js` (skipping
-zero directories), `src/ui/main.js` (skipping one directory), and
-`src/ui/components/main.js` (skipping two directories).
+The double star `**` wildcard matches across directory separators only
+when it is adjacent to a directory separator (preceded or followed by a
+slash). In this form, it matches zero or more characters across directory
+levels. For example, `foo/**/bar` matches `foo/bar`, `foo/a/bar`, and
+`foo/a/b/bar`; `**/build` matches `build` and `foo/bar/build`; and
+`src/**.js` matches `src/main.js` and `src/ui/components/main.js`.
 The standalone form `/**/` is not accepted as a complete pattern.
 
+When `**` is not adjacent to a slash, it behaves like `*` and does not
+match directory separators. For example, `**.jpg` matches `photo.jpg`
+within the current directory, but does not match `dir/photo.jpg`. Use
+`**/*.jpg` for that purpose.
+
 Character classes using square brackets match a single character from a
 specified set or range. Like the other single character patterns, they do
 not match directory separators. Classes support ranges and negation using
@@ -1715,8 +1714,8 @@ an exclamation mark.
 
 The fundamental distinction to remember is that `*`, `?`, and character
 classes all respect directory boundaries and only match within a single path
-component, while `**` is the only pattern that can match across directory
-separators.
+component, while `**` can match across directory separators only when
+adjacent to a slash.
 
 There are four different types of patterns: