User:Ponor/wAwB

Access control

wAwB checks your permissions automatically on startup.

• Administrators always get full access to the tool.
• CheckPage: The script looks for a JSON configuration page at Project:AutoWikiBrowser/CheckPageJSON.
  • If your username is in enabledusers: You have full access to manual saving.
  • If your username is in enabledbots AND you belong to the 'bot' user group: You have access to Bot mode (automated saving).
• Fallback – no CheckPage: If the JSON page does not exist on the wiki:
  • Users with < 500 edits cannot save.
  • Users with > 500 edits can save, but are rate-limited to one edit every 30 seconds.
  • Bot mode is disabled for everyone.

Technical safety

Critical processing tasks (such as executing your Find/Replace rules and custom scripts) are run inside a Web worker. This ensures that complex operations do not freeze your browser interface. To prevent infinite loops or crashes, the script enforces a strict 5-second timeout. If your custom script or regex takes longer than 5 seconds to process a single page, the operation will be aborted for safety. This limit can be changed by setting the global variable window.wa_timeout = 5000 to some other value (in milliseconds) before the invocation of the script.

Configuration

A few global variables defined before the mw.loader invocation can change the script's behavior. Here are their default values:

// 5000 millisecond timeout for replacement rules and scripts
window.wa_timeout = 5000;
// fetch no more than ten thousand titles
window.wa_fetchLimit = 10000;

// documentation URL
window.wa_docUrl = "https://en.wikipedia.org/wiki/User:Ponor/wAwB";
// portlet link and script window titles
window.wa_editIn = "Edit in wAwB";
// portlet tooltip 
window.wa_toolTip = "Automated editing gadget";

Toolbar (Project management)

Located at the top of the left panel, these buttons allow you to persist your work.

Save project Downloads a .json file to your computer containing your entire current state:

• All defined Find/Replace rules.
• All protection settings (Templates, Refs, etc.).
• Skip logic and content filters.
• Custom pre/post scripts.
• The current page list and the edit summary.

Load project Restores a previously saved configuration file.

Source (Getting pages)

This panel allows you to generate the list of pages you want to edit.

• Mode: Select how to find pages:
  • Category: Enter a category name (e.g., "Chemistry"). Options allow including subcategories or files. API docs
  • Pages linking to...: Finds backlinks. API docs
  • Links on page...:
  • Pages with prefix...: All pages starting with a specific string. API docs
  • Watchlist: Loads your entire watchlist. API docs
  • Wiki search: Use MediaWiki search syntax. CirrusSearch docs · API docs
  • User contributions: Titles a user contributed to between two timestamps. API docs
  • Pages with Property: Pages with one of page properties, such as disambiguation, displaytitle, defaultsort. API docs
• Namespaces: A scrolling list of namespaces. Ensure you check the relevant ones (e.g., '0' for Articles, '14' for Categories).
• Add to list: Fetches the pages and appends them to the processing list.

Rules (Find & Replace)

The core editing logic. wAwB allows you to define multiple Find and Replace rules. These are processed sequentially from top to bottom.

• Find: The text to search for.
• Replace: The text to insert.
• Regex toggle:
  • Off (Default): Simple text replacement. Note: It replaces all occurrences, not just the first one.
  • On: Uses JavaScript regular expressions.
  • Flags: When regex is on, a small box appears (default gmu). You can change regex flags here (e.g., remove g to replace only the first match, add i for case-insensitivity).
  • {} JavaScript function: treat the input as a JavaScript function body, with access to a set of relevant variables.

Rule controls: Each rule box includes specific controls to manage your workflow:

Reorder: Use the Up and Down arrows on the left side of a rule to change its execution order. This is useful when one rule relies on the output of a previous rule.

Toggle active: Use the button to enable or disable a rule without deleting it.

• Blue: The rule is Active and will be applied.
• Grey: The rule is Inactive and will be ignored.

Delete: Permanently removes the rule.

External rules

wAwB supports loading external lists of find-and-replace rules, useful for applying common typo fixes or shared maintenance tasks. These rules are treated as regular expressions.

Do note that AutoWikiBrowser uses .NET regex engine, which behaves differently from the JavaScript regex engine used in web browsers. For example, in JavaScript characters like š, č, ü are seen as "non-word" characters (\W), so they will not be matched by the shortcut \w. The word boundary \b is always ASCII-only, even if Unicode-aware regex features are enabled using the u flag. Unicode lookarounds (?<!\p{L}) (not preceded by a letter) and (?!\p{L}) (not followed by a letter) should be used instead of the word boundary \b, with the u flag set.

• Project typos: Toggle "Project:AutoWikiBrowser/Typos" to fetch and apply rules defined on that wiki page. The script parses the page for valid XML tags. For additional details, see Project:AutoWikiBrowser/Typos on this or your local wiki.
• Local rules: Use the "Load file" button to upload a local text file containing your own rules. These rules are active for the current session only and are not saved within the wAwB project .json file.

<Typo word="Description of the fix" find="\bteh\b" replace="the" />
<Typo word="Fixing header" find="==\s*External links\s*==" replace="== External links ==" />
<Typo word="Broken rule" find="..." replace="..." disabled />

Processing (The control center)

When you click Start, the tool enters "processing mode".

• Editing locked: The main editor and configuration inputs become Read-Only to prevent accidental changes during execution.
• Inspect mode: Unlike previous versions, the configuration panels (Source, Rules, Scripts) remain accessible. You can expand them to verify your regex or settings while the bot is running, though you cannot modify them until you click Stop.

• Summary: Enter your edit summary here. You can use variables (like $xA) here to create dynamic summaries for every edit.
• Buttons:

Start/Stop Toggles the processing session. "Start" locks the list and loads the first page. "Stop" unlocks the interface.

Diff Re-runs the diff calculation (useful if you manually edited the text area).

Skip Ignores the current page and loads the next one without saving.

Preview Renders, in the top right panel, a visual preview of the page in the user's current skin. All links in the preview will open in a new tab/window to prevent losing your work. The preview is generated on Wikimedia servers and is not instantaneous; use sparingly.

Save: Commits the edit to the wiki.

• List box: The text area at the bottom shows the queue of pages. You can manually edit this list.
• Toolbar:
  • Sort (A-Z or Z-A): Sorts the list alphabetically.
  • Dedup (Funnel): Removes duplicate page titles.
  • Clear (Trash): Wipes the list.

Skip (Filtering)

Define conditions under which a page should be automatically skipped.

• Redirects:
  • Edit (Default): Edits the redirect page itself (e.g., fixing a typo in a redirect category).
  • Follow: Resolves the redirect and edits the target page instead.
  • Skip: Ignores redirects entirely.
• Skip logic:
  • Skip if no changes: Crucial for maintenance runs. If your rules don't match anything, the page is skipped.
  • Skip if missing: Prevents creating new pages by accident.
  • Skip if exists: Useful if you are mass-creating pages and don't want to overwrite existing ones.
• Content filters: Skip the page if the text contains (or does not contain) a specific string or regex match.
• Category filters: Skip the page if it is (or is not) in any of the categories given as a list of category names (without the namespace prefix) separated by vertical bars, as in First category|Second category|Third category.

Any JavaScript user function within wAwB can emit a skip command for even more powerful control of skipping.

Protection

Use this panel to "shield" parts of the text from your Rules. Protected text is temporarily hidden from the Find/Replace engine (using a uniques sequence of special characters)^{[note 2]} and restored afterwards. As a second options, the same isolated parts of the text can be the only target of your replacement rules.

The shielding may not always be perfect, due to the complexities of wikitext, and should be used with great care. Some of the following protections may overlap—enable those that suit your needs best.

• Nowiki: Protects everything within <nowiki>...</nowiki>, including the tags.
• Comments: Protects HTML comments <!-- ... -->.
• Headers: Protects section headings, i. e. lines starting and ending with ==.
• Templates: Protects content inside {{...}}. By default, it protects all top-level templates (templates that are not nested inside other templates). However, which templates should be protected (or targeted) can be filtered by a regular expression.
• Tables: Protects content inside {|...|}, when the two delimiters start a new line.
• Images: Protects content inside [[Image:...|...|...]]. All local namespace aliases are supported: File: or Image: or Slika: or Слика: etc.
• Refs: Protects citations inside <ref>...</ref>.
• Blocks: Protects code blocks such as <math>, <pre>, <source>, <syntaxhighlight>, <code>, <gallery>.
• Categories: Protects category links [[Category:...|...]]. All local namespace aliases are supported.
• File names: Protects the target filename in file links [[File:...| and galleries where the File: prefix is provided. Local namespace aliases are supported
• Targets: Protects targets of all wikilink-type wikitext, which includes the Files and Categories syntax.
  • Example: In [[Target|Label]], "Target" is protected, but "Label" can be modified by rules.
  • Example: In [[Image:Some name.jpeg|thumb|Caption]], "Image:Some name.jpeg" is protected, the rest can be modified by rules.
• External links: Protects evertyhing inside of [… …].
• URLs: Protects raw URLs starting with http:// or https://.

Page actions & maintenance

Administrator mode

For users with sufficient rights (administrators), wAwB includes a specialized toolkit for page maintenance. Administrators will see an additional accordion tab labeled Admin actions. To use these tools, you must first toggle the Enable admin actions switch.

Safe mode enforcement: When Admin mode is enabled, the tool enters a strict "Maintenance only" state:

• The editor becomes Read-Only (text cannot be modified manually).
• All find&replace rules and custom scripts are disabled to ensure you are seeing the exact, raw wikitext of the current revision.
• Standard "Save", "Preview", and "Diff" buttons are disabled.

1. Template filter

Instead of protecting or targeting all top-level templates on the page, a selection can be made using a regular expression. If the regular expression starts with a ^, the top-level templates will be chosen that match that regular expression. If it does not start with a ^, the whole top-level template will be protected if it contains the matched template anywhere within.

Example wikitext:

1. {{Top template|...|...{{other template|..}}...}}
2. {{Other template|..}}

If the template filter regex is other template, whatever is within {{Top template|...}} on line 1 gets protected, and everything that is within {{Other template|...}} on line 2 gets protected. If, however, the regex is ^other template, only the top-level {{Other template|...}} gets protection.^{[note 3]}

The regular expression can contain alternations, such as infobox rail line|infobox railway|railway or ^(infobox heritage|intangible heritage).

2. Pre-parse mode

The pre-parse feature allows you to filter a large list of pages in the background, keeping only those that actually require changes based on your current configuration. This is useful for filtering out thousands of pages that don't match your regex rules without having to load them one by one in the editor.

Click the Pre-parse button located directly below the page list.

The script first deduplicates the current list of titles, then fetches page content in batches (50 at a time) to minimize API calls. It applies your current regex rules, JavaScript, and Skip logic (including "Skip if text contains") to each page in memory. If a page matches a Skip rule or, optionally, results in no changes, it is removed from the list. The page that was kept is moved to the bottom of the list, below a ####STOP marker. The batch processing repeats until it reaches the ####STOP line. Click the button again (labeled "Stop pre-parse") to pause the process. When finished, your list will contain only the pages that require edits. You can then click "Start" to review and save them.

Note: Pre-parsing does not save edits to Wikipedia. It only filters your local list. Use the button sparingly, as the page is downloaded each time you start the process.

You can use special syntax in the page list to control the workflow:

Comments

Any line starting with #### is treated as a comment.

The stop marker

The specific line ####STOP acts as a hard barrier.

• In manual mode: If the script encounters this line while clicking "Next" or "Save", it will automatically stop the process (equivalent to clicking the "Stop" button).
• In pre-parse mode: The script uses this marker to separate "Pending" pages (top) from "Processed/Kept" pages (bottom).

3. List variables

You can pass custom data for each page using pipe-separated values in the list box. This is useful for dynamic replacements based on per-page data.

• Syntax: PageTitle|Value1|Value2|…

Each pipe-separated value in your page list generates variables $xA through $xZ directly in the Find and Replace fields of your rules. The variable $xx will hold the page title itself.

• Variables:
  • $xA = First value (Value1)
  • $xB = Second value (Value2)
  • ... up to $xZ
  • $xx = Page title from the page list.
• Where to use:
  • Replace rules: Use $xA in the "Replace" or "Find" fields to insert the variable.
  • Edit summary: Use $xA in the summary box for dynamic summaries (e.g., "Fixing link to $xA").
  • Scripts: Accessed via the vars object (e.g., vars.$xA).

The script injects the content of the variable into your search string before the search is performed. The behavior depends on whether you are using Regex mode or Normal mode.

4. Replace functions

For scenarios where simple regex replacement isn't enough (e.g., math calculations, conditional logic, or reformatting dates), wAwB supports JavaScript function replacement.

To use this feature:

1. Enable Regex for the rule.
2. Click the {} (Code) icon next to the regex toggle.
3. The "Replace" field will change its placeholder to indicate code mode.

In this mode, the "Replace" field accepts the body of a JavaScript function. This function is executed for every match found by your regex.

var km = parseInt(groups[0]);
return (km * 1000) + " m";

var catName = groups[0];
// If category is "Stub", remove it (return empty string)
if (catName === "Stub") return "";
// Otherwise, keep it as is
return match;

// Inject the value of $xA from your page list
return "The value is " + vars.$xA;

5. Scripts

For complex logic that cannot be handled by simple Find/Replace you can write JavaScript functions that accept three arguments: text (the page content), vars (the variables from the titles list), and shared (an initially empty object shared among all the functions, for the current page)

return "{{Unreferenced}}\n" + text.toLowerCase();

window.wAwB_Pre = function(text, vars, shared) {
	// Example: Use a variable from the list
	if (vars.$xA) {
		return text + "\nSee also: [[" + vars.$xA + "]]";
	}
	return text;
};

window.wAwB_Post = function(text, vars, shared) {
	// Example: specific logic to clean up artifacts
	function doTrim(t) {
		return t.trim();
	};

	return doTrim(text);
};

6. Advanced scripting

wAwB includes advanced scripting capabilities that allow you to pass data between different processing stages and conditionally skip pages based on complex logic.

// Detect if the page started with a specific template
shared.hadMaintenanceTag = text.includes("{{Under construction");
return text;

// If we removed the tag, add a custom summary note
if (shared.hadMaintenanceTag && !text.includes("{{Under construction")) {
	console.log("Warning: Maintenance tag removed");
}
return text;

return { skip: true, reason: "Your reason here" };

if (text.length < 500) {
	return { skip: true, reason: "Page too short (<500 chars)" };
}
return text;

if (shared.foundBadThing) {
	return { skip: true, reason: "Skipped to avoid editing bad pattern manually" };
}
return text;

async function wAwB_Post(text, vars, shared) {
	try {
		// Note: Use the absolute URL because workers have blob:// origins
		const apiUrl = self.location.origin + '/w/api.php';

		// mediawiki.org/wiki/API:Parse
		const params = new URLSearchParams({
			action: 'parse',
			format: 'json',
			text: text,
			prop: 'categories',
			contentmodel: 'wikitext',
			origin: '*'
		});

		const response = await fetch(apiUrl, {
			method: 'POST',
			body: params
		});

		const data = await response.json();

		// Logic...
		if (data.parse && data.parse.categories) {
			var categories = data.parse.categories;

			// Extract just the category names
			var categoryNames = categories.map(function(cat) {
				return cat['*'];
			});
			console.log(categoryNames);
			if (categoryNames.contains("My unwanted category")) {
				return {
					skip: true,
					reason: "Skipped because..."
				};
			}
		}

		return text;
	} catch (e) {
		console.log(e.message);
		return {
			skip: true,
			reason: "Fetch error: " + e.message
		};
	}
}