Modul:Params

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="mad">
  <siteinfo>
    <sitename>Wikipedia</sitename>
    <dbname>madwiki</dbname>
    <base>https://mad.wikipedia.org/wiki/Tan%C3%A8yan</base>
    <generator>MediaWiki 1.47.0-wmf.24</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Mèḍia</namespace>
      <namespace key="-1" case="first-letter">Spesial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Pakanḍhâ'ân</namespace>
      <namespace key="2" case="first-letter">Pangangghuy</namespace>
      <namespace key="3" case="first-letter">Pakanḍhâ'ânna pangangghuy</namespace>
      <namespace key="4" case="first-letter">Wikipèḍia</namespace>
      <namespace key="5" case="first-letter">Pakanḍhâ'ânna Wikipèḍia</namespace>
      <namespace key="6" case="first-letter">Bhengkek</namespace>
      <namespace key="7" case="first-letter">Pakanḍhâ'ânna bhengkek</namespace>
      <namespace key="8" case="first-letter">MèḍiaWiki</namespace>
      <namespace key="9" case="first-letter">Pakanḍhâ'ânna MèḍiaWiki</namespace>
      <namespace key="10" case="first-letter">Cèṭa'an</namespace>
      <namespace key="11" case="first-letter">Pakanḍhâ'ânna cèṭa'an</namespace>
      <namespace key="12" case="first-letter">Bhântowan</namespace>
      <namespace key="13" case="first-letter">Pakanḍhâ'ânna bhântowan</namespace>
      <namespace key="14" case="first-letter">Bhângsa</namespace>
      <namespace key="15" case="first-letter">Pakanḍhâ'ânna bhângsa</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Modul</namespace>
      <namespace key="829" case="first-letter">Pembicaraan Modul</namespace>
      <namespace key="1728" case="first-letter">Acara</namespace>
      <namespace key="1729" case="first-letter">Pembicaraan Acara</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Modul:Params</title>
    <ns>828</ns>
    <id>3367</id>
    <revision>
      <id>67241</id>
      <parentid>66776</parentid>
      <timestamp>2026-10-27T22:18:11Z</timestamp>
      <contributor>
        <username>Grufo</username>
        <id>5223</id>
      </contributor>
      <comment>Update from [[d:Special:GoToLinkedPage/mediawikiwiki/Q122696746|master]] using [[mw:Synchronizer| #Synchronizer]]</comment>
      <origin>67241</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="91286" sha1="ed6uj3jkl9sb18ckis1vsieht07yb7c" xml:space="preserve">require[[strict]]


	---                                        ---
	---     PRIVATE ENVIRONMENT                ---
	---    ________________________________    ---
	---                                        ---


	--[[ Abstract utilities ]]--
	----------------------------


-- Helper function for `string.gsub()` (for managing zero-padded numbers)
local function zero_padded (str)
	return ('%03d%s'):format(#str, str)
end


-- Helper function for `table.sort()` (for natural sorting)
local function natural_sort (var1, var2)
	return var1:gsub('%d+', zero_padded) &lt; var2:gsub('%d+', zero_padded)
end


-- Return a copy or a reference to a table
local function copy_or_ref_table (src, refonly)
	if refonly then return src end
	local newtab = {}
	for key, val in pairs(src) do newtab[key] = val end
	return newtab
end


-- Copy at most N items (of all kinds) from `src` to `dest` and return `dest`
local function copy_table_maxn (dest, src, len)
	local idx = 1
	for key, val in pairs(src) do
		dest[key], idx = val, idx + 1
		if idx &gt; len then break end
	end
	return dest
end


-- Remove some numeric elements from a table, shifting everything to the left
local function remove_numeric_keys (tbl, idx, len)
	local cache, tmp = {}, idx + len - 1
	for key, val in pairs(tbl) do
		if type(key) == 'number' and key &gt;= idx then
			if key &gt; tmp then cache[key - len] = val end
			tbl[key] = nil
		end
	end
	for key, val in pairs(cache) do tbl[key] = val end
end


-- Make a reduced copy of a table (shifting in both directions if necessary)
local function copy_table_reduced (tbl, idx, len)
	local ret, tmp = {}, idx + len - 1
	if idx &gt; 0 then
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key &lt; idx then
				ret[key] = val
			elseif key &gt; tmp then ret[key - len] = val end
		end
	elseif tmp &gt; 0 then
		local nshift = 1 - idx
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' then ret[key] = val
			elseif key &gt; tmp then ret[key - tmp] = val
			elseif key &lt; idx then ret[key + nshift] = val end
		end
	else
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key &gt; tmp then
				ret[key] = val
			elseif key &lt; idx then ret[key + len] = val end
		end
	end
	return ret
end


-- Make an expanded copy of a table (shifting in both directions if necessary)
local function copy_table_expanded (tbl, idx, len)
	local ret, tmp = {}, idx + len - 1
	if idx &gt; 0 then
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key &lt; idx then
				ret[key] = val
			else ret[key + len] = val end
		end
	elseif tmp &gt; 0 then
		local nshift = idx - 1
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' then ret[key] = val
			elseif key &gt; 0 then ret[key + tmp] = val
			elseif key &lt; 1 then ret[key + nshift] = val end
		end
	else
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key &gt; tmp then
				ret[key] = val
			else ret[key - len] = val end
		end
	end
	return ret
end


-- Given a table, create two new tables containing the sorted list of keys
local function get_sorted_key_list (tbl, sort_fn)
	local nums, words, nn, nw = {}, {}, 1, 1
	for key, val in pairs(tbl) do
		if type(key) == 'number' then nums[nn], nn = key, nn + 1
		else words[nw], nw = key, nw + 1 end
	end
	table.sort(nums)
	table.sort(words, sort_fn)
	return nums, words, nn - 1, nw - 1
end


-- Parse a parameter name string and return it as a string or a number
local function get_param_name (par_str)
	local ret = par_str:match'^%s*(.-)%s*$'
	if ret ~= '0' and ret:find'^%-?[1-9]%d*$' == nil then return ret end
	return tonumber(ret)
end


-- Move a key from a table to another, but only if under a different name and
-- always parsing numeric strings as numbers
local function steal_if_renamed (val, src, skey, dest, dkey)
	local realkey = get_param_name(dkey)
	if skey ~= realkey then dest[realkey], src[skey] = val, nil end
end


	--[[ Public strings ]]--
	------------------------


-- Special match keywords (functions and modifiers MUST avoid these names)
local mkeywords = {
	['or'] = 0,
	pattern = 1,
	plain = 2,
	strict = 3
}


-- Sort functions (functions and modifiers MUST avoid these names)
local sortfunctions = {
	alphabetically = false,
	naturally = natural_sort
}


-- Callback styles for the `mapping_*` and `renaming_*` class of modifiers
-- (functions and modifiers MUST avoid these names)
--[[

Meanings of the columns:

  col[1] = Loop type (0-3)
  col[2] = Number of module arguments that the style requires (1-3)
  col[3] = Minimum number of sequential parameters passed to the callback
  col[4] = Name of the callback parameter where to place each parameter name
  col[5] = Name of the callback parameter where to place each parameter value
  col[6] = Argument in the modifier's invocation that will override `col[4]`
  col[7] = Argument in the modifier's invocation that will override `col[5]`

A value of `-1` indicates that no meaningful value is stored (i.e. `nil`)

]]--
local mapping_styles = {
	names_and_values = { 3, 2, 2, 1, 2, -1, -1 },
	values_and_names = { 3, 2, 2, 2, 1, -1, -1 },
	values_only = { 1, 2, 1, -1, 1, -1, -1 },
	names_only = { 2, 2, 1, 1, -1, -1, -1 },
	names_and_values_as = { 3, 4, 0, -1, -1, 2, 3 },
	names_only_as = { 2, 3, 0, -1, -1, 2, -1 },
	values_only_as = { 1, 3, 0, -1, -1, -1, 2 },
	blindly = { 0, 2, 0, -1, -1, -1, -1 }
}


-- Memory slots (functions and modifiers MUST avoid these names)
local memoryslots = {
	h = 'header',
	f = 'footer',
	i = 'itersep',
	l = 'lastsep',
	n = 'ifngiven',
	p = 'pairsep',
	s = 'oxfordsep'
}


-- Possible trimming modes for the `parsing` modifier
local trim_parse_opts = {
	trim_none = { false, false },
	trim_positional = { false, true },
	trim_named = { true, false },
	trim_all = { true, true }
}


-- Possible string modes for the iteration separator in the `parsing` and
-- `reinterpreting` modifiers
local isep_parse_opts = {
	splitter_pattern = false,
	splitter_string = true
}


-- Possible string modes for the key-value separator in the `parsing` and
-- `reinterpreting` modifiers
local psep_parse_opts = {
	setter_pattern = false,
	setter_string = true
}


-- Possible position references for the `splicing` modifier
local position_references = {
	add_nothing = 0,
	add_smallest_number = 1,
	add_last_of_sequence = 2,
	add_largest_number = 3
}


-- Possible modes for the `reassigning` modifier
local a_modes = {
	transfer = 0,
	clone = 1,
	rename = 2,
	copy = 3,
	sacrifice = 4,
	provide = 5,
	spare = 7
}


-- Functions and modifiers MUST avoid these names too: `here`, `in_substack`,
-- `let`, `expose`, `use`, `with_flushed_glue`, `without_flushed_glue`
-- `without_sorting`


	--[[ Private constants ]]--
	---------------------------


-- Hard-coded name of the module (to avoid going through `frame:getTitle()`)
local modulename = 'Module:Params'


-- The functions listed here declare that they don't need the
-- `frame:getParent().args` metatable to be copied into a regular table; if 
-- they are modifiers they also guarantee that they will make their own
-- (modified) copy available
local refparams = {
	call_for_each_group = true,
	combining = true,
	combining_by_calling = true,
	combining_values = true,
	concat_and_call = true,
	concat_and_invoke = true,
	concat_and_magic = true,
	count = true,
	grouping_by_calling = true,
	mixing_names_and_values = true,
	keeping_at_most = true,
	renaming_by_mixing = true,
	renaming_to_sequence = true,
	renaming_to_uppercase = true,
	renaming_to_lowercase = true,
	shifting = true,
	splicing = true,
	value_of = true,
	with_name_matching = true
}


-- Maximum number of numeric parameters that can be filled, if missing (we
-- chose an arbitrary number for this constant; you can discuss about its
-- optimal value at Module talk:Params)
local maxfill = 1024


-- The private table of functions
local library = {}


-- Functions and modifiers that can only be invoked in first position
local static_iface = {}


	--[[ Private functions ]]--
	---------------------------


-- Create a new context
local function context_new (child_frame, first_fn_name)
	local main_frame, tpipe = child_frame:getParent(), { first_fn_name }
	for key, val in pairs(child_frame.args) do
		if type(key) == 'number' and key &gt; 0 then tpipe[key + 1] = val
		else tpipe[key] = val end
	end
	return {
		frame = main_frame,
		pipe = tpipe,
		oparams = main_frame.args,
		firstposonly = static_iface,
		iterfunc = pairs,
		fnpos = 1,
		sorttype = 0,
		n_parents = 0,
		n_children = 0,
		n_available = maxfill
	}
end


-- Move to the next action within the user-given list
local function context_iterate (ctx, next_fn_pos, trimmed_fname)
	local fname = trimmed_fname or ctx.pipe[next_fn_pos] and
		ctx.pipe[next_fn_pos]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		': You must specify a function to call', 0) end
	if library[fname] == nil then
		if ctx.firstposonly[fname] == nil then error(modulename ..
			': The function ‘' .. fname .. '’ does not exist', 0)
		else error(modulename .. ': The ‘' .. fname ..
			'’ directive can only appear in first position', 0)
		end
	end
	ctx.fnpos = next_fn_pos
	return library[fname]
end


-- Main loop
local function main_loop (ctx, start_with)
	local fn = start_with
	repeat fn = fn(ctx) until not fn
	if ctx.n_parents &gt; 0 then error(modulename ..
		': One or more ‘merging_substack’ directives are missing', 0) end
	if ctx.n_children &gt; 0 then error(modulename ..
		', For some of the snapshots either the ‘flushing’ directive is missing or a group has not been properly closed with ‘merging_substack’', 0) end
end


-- Load a `setting`-like directive string into the `dest` table
local function set_strings_from_opts (dest, opts, offs)
	local cmd
	if opts[offs] == nil then return offs - 1 end
	cmd = opts[offs]:gsub('%s+', ''):gsub('/+', '/'):match'^/*(.*[^/])'
	if cmd == nil then return offs end
	local vname, chr
	local amap, sep, argc = {}, string.byte('/'), offs + 1
	for idx = 1, #cmd do
		chr = cmd:byte(idx)
		if chr == sep then
			for key, val in ipairs(amap) do
				dest[val], amap[key] = opts[argc], nil
			end
			argc = argc + 1
		else
			vname = memoryslots[string.char(chr)]
			if vname == nil then error(modulename ..
				', ‘setting’: Unknown slot ‘' .. string.char(chr) .. '’', 0) end
			table.insert(amap, vname)
		end
	end
	for key, val in ipairs(amap) do dest[val] = opts[argc] end
	return argc
end


-- Add a new stack of parameters to `ctx.children`
local function new_substack (ctx)
	local currsnap, newparams = ctx.n_children + 1, {}
	if ctx.children == nil then ctx.children = { newparams }
	else ctx.children[currsnap] = newparams end
	ctx.n_children = currsnap
	return newparams
end


-- Parse a raw argument containing a `sortfunctions` directive, or
-- `'without_sorting'`, or `nil`
local function load_sort_opt (raw_arg)
	local trarg
	if raw_arg ~= nil then trarg = raw_arg:match'^%s*(.*%S)' end
	if trarg == nil then return nil, 1, false, nil end
	if trarg == 'without_sorting' then return nil, 2, false, nil end
	local tmp = sortfunctions[trarg]
	if tmp == nil then return nil, 1, false, trarg end
	return tmp or nil, 2, true, nil
end


-- Parse optional user arguments of type `...|[let/use]|[...]|[let/use]|[...]|
-- [number of additional parameters]|[parameter 1]|[parameter 2]|[...]`
local function load_child_opts (src, start_from, append_after, params)
	local tnamed, tmp1, tmp2
	local pin, tbl, mem = start_from, {}, {}
	while src[pin] ~= nil and src[pin + 1] ~= nil do
		tmp1 = src[pin]:match'^%s*(.*%S)'
		if tmp1 == 'let' and src[pin + 2] ~= nil then
			tmp1 = get_param_name(src[pin + 1])
			tbl[tmp1], pin = src[pin + 2], pin + 3
--[[
		elseif tmp1 == 'expose' then
			tmp1 = get_param_name(src[pin + 1])
			tmp2 = params[tmp1]
			mem[tmp1], tbl[tmp1], pin = tmp2, tmp2, pin + 2
]]--
		elseif tmp1 == 'use' and src[pin + 2] ~= nil then
			tmp1 = get_param_name(src[pin + 2])
			tmp2 = params[tmp1]
			mem[tmp1], tbl[get_param_name(src[pin + 1])], pin =
				tmp2, tmp2, pin + 3
		else break end
	end
	local tnew = copy_or_ref_table(params, next(mem) == nil)
	for key in pairs(mem) do tnew[key] = nil end
	if pin ~= start_from then tnamed, tbl = tbl, {} end
	tmp1 = tonumber(src[pin])
	if tmp1 ~= nil and math.floor(tmp1) == tmp1 then
		if tmp1 &lt; 0 then tmp1 = -1 end
		tmp2 = append_after - pin
		for idx = pin + 1, pin + tmp1 do tbl[idx + tmp2] = src[idx] end
		pin = pin + tmp1 + 1
	end
	if tnamed ~= nil then
		for key, val in pairs(tnamed) do tbl[key] = val end
	end
	return tbl, pin, tnew, mem
end


-- Load the optional arguments of some of the `mapping_*` and `renaming_*`
-- class of modifiers
local function load_callback_opts (src, start_from, default_style, params)
	local style, shf
	local tmp = src[start_from + 1]
	if tmp ~= nil then style = mapping_styles[tmp:match'^%s*(.-)%s*$'] end
	if style == nil then style, shf = default_style, start_from - 1
	else shf = start_from end
	local n_exist, karg, varg = style[3], style[4], style[5]
	tmp = style[6]
	if tmp &gt; -1 then
		karg = src[tmp + shf]:match'^%s*(.-)%s*$'
		if karg == '0' or karg:find'^%-?[1-9]%d*$' ~= nil then
			karg = tonumber(karg)
			n_exist = math.max(n_exist, karg)
		end
	end
	tmp = style[7]
	if tmp &gt; -1 then
		varg = src[tmp + shf]:match'^%s*(.-)%s*$'
		if varg == '0' or varg:find'^%-?[1-9]%d*$' ~= nil then
			varg = tonumber(varg)
			n_exist = math.max(n_exist, varg)
		end
	end
	tmp = style[1]
	local dest, argc, tnew, mem = load_child_opts(src, style[2] + shf,
		n_exist, params)
	if (tmp == 3 or tmp == 2) and dest[karg] ~= nil then
		tmp = tmp - 2 end
	if (tmp == 3 or tmp == 1) and dest[varg] ~= nil then
		tmp = tmp - 1 end
	return dest, argc, tmp, karg, varg, tnew, mem
end


-- Parse the arguments of some of the `mapping_*` and `renaming_*` class of
-- modifiers
local function load_replace_args (opts, offs, whoami)
	if opts[offs + 1] == nil then error(modulename ..
		', ‘' .. whoami .. '’: No pattern string was given', 0) end
	if opts[offs + 2] == nil then error(modulename ..
		', ‘' .. whoami .. '’: No replacement string was given', 0) end
	local tn, flg
	local ptn, repl, nmax, argc =
		opts[offs + 1], opts[offs + 2], tonumber(opts[offs + 3]), 3
	if nmax ~= nil then argc = 4
	elseif opts[offs + 3] ~= nil then
		tn = opts[offs + 3]:match'^%s*(.*%S)'
		if tn == nil then argc = 4 end
	end
	if tn == nil and opts[offs + argc] ~= nil then
		tn = opts[offs + argc]:match'^%s*(.*%S)'
	end
	if tn ~= nil then
		flg = mkeywords[tn]
		if flg ~= nil then tn = nil end
	end
	if flg == 0 then flg = nil elseif flg ~= nil then argc = argc + 1 end
	return ptn, repl, nmax, flg, offs + argc, (nmax ~= nil and nmax &lt; 1) or
		(flg == 3 and ptn == repl), tn
end


-- Parse the arguments of the `with_*_matching` class of modifiers
local function load_pattern_args (opts, offs, whoami)
	local tn, kwid
	local ptns, arg, state, nptns, idx = {}, opts[offs + 1], 0, 0, offs + 2
	while arg ~= nil do
		if state == 0 then
			nptns, state = nptns + 1, -1
			ptns[nptns] = { arg, false, false }
		else
			tn = arg:match'^%s*(.*%S)'
			kwid = tn and mkeywords[tn]
			if kwid == nil or (state &gt; 0 and kwid &gt; 0) then break
			else
				state = kwid
				if state &gt; 1 then ptns[nptns][2] = true end
				if state == 3 then ptns[nptns][3] = true end
			end
		end
		arg, idx = opts[idx], idx + 1
	end
	if state == 0 then error(modulename ..
		', ‘' .. whoami .. '’: No pattern was given', 0) end
	return ptns, nptns, idx - 1, kwid == nil and tn or nil
end


-- Load the optional arguments of the `parsing`, `reinterpreting` and
-- `evaluating` modifiers
local function load_parse_opts (opts, offs, isp, psp)
	local tn, tmp
	local optslots, noptslots, argc, trimn, trimu, iplain, pplain =
		{ true, true, true }, 3, offs, true, false, true, true
	repeat
		noptslots, tmp = noptslots - 1, opts[argc]
		tn = tmp and tmp:match'^%s*(.*%S)'
		if tn == nil then break end
		if optslots[1] ~= nil and trim_parse_opts[tn] ~= nil then
			tmp = trim_parse_opts[tn]
			trimn, trimu, optslots[1] = tmp[1], tmp[2], nil
		elseif optslots[2] ~= nil and isep_parse_opts[tn] ~= nil then
			argc = argc + 1
			iplain, isp, optslots[2] = isep_parse_opts[tn],
				opts[argc], nil
		elseif optslots[3] ~= nil and psep_parse_opts[tn] ~= nil then
			argc = argc + 1
			pplain, psp, optslots[3] = psep_parse_opts[tn],
				opts[argc], nil
		else break end
		argc, tn = argc + 1, nil
	until noptslots &lt; 1
	return isp, iplain, psp, pplain, trimn, trimu, argc, tn
end


-- Map parameters' values using a custom callback and a referenced table
local value_maps = {
	[0] = function (tbl, margs, karg, varg, fn)
		for key in pairs(tbl) do tbl[key] = fn() end
	end,
	[1] = function (tbl, margs, karg, varg, fn)
		for key, val in pairs(tbl) do
			margs[varg] = val
			tbl[key] = fn()
		end
	end,
	[2] = function (tbl, margs, karg, varg, fn)
		for key in pairs(tbl) do
			margs[karg] = key
			tbl[key] = fn()
		end
	end,
	[3] = function (tbl, margs, karg, varg, fn)
		for key, val in pairs(tbl) do
			margs[karg], margs[varg] = key, val
			tbl[key] = fn()
		end
	end
}


-- Private table for `map_names()`
local name_thieves = {
	[0] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end,
	[1] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			rargs[varg] = val
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end,
	[2] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			rargs[karg] = key
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end,
	[3] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			rargs[karg], rargs[varg] = key, val
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end
}


-- Map parameters' names using a custom callback and a referenced table
local function map_names (tbl, rargs, karg, varg, looptype, fn)
	local cache = {}
	name_thieves[looptype](cache, tbl, rargs, karg, varg, fn)
	for key, val in pairs(cache) do tbl[key] = val end
end


-- Return a new table that contains `src` regrouped according to the numeric
-- suffixes in its keys
local function make_groups (src)
	-- NOTE: `src` might be the original metatable!
	local prefix, gid
	local groups = {}
	for key, val in pairs(src) do
		-- `key` must only be a string or a number...
		if type(key) == 'string' then
			prefix, gid = key:match'^%s*(.-)%s*(%-?%d*)%s*$'
			gid = tonumber(gid) or ''
		else prefix, gid = '', key end
		if groups[gid] == nil then groups[gid] = {} end
		if prefix == '0' or prefix:find'^%-?[1-9]%d*$' ~= nil then
			prefix = tonumber(prefix)
			if prefix &lt; 1 then prefix = prefix - 1 end
		end
		groups[gid][prefix] = val
	end
	return groups
end


-- Split into parts a string containing the `$#` and `$@` placeholders and
-- return the information as a skeleton table, a canvas table and a length
local function parse_placeholder_string (target)
	local skel, canvas, idx, s_pos, e_pos =
		{}, {}, 1, 1, string.find(target, '%$[@#]', 1, false)
	while e_pos ~= nil do
		canvas[idx], skel[idx + 1] =
			target:sub(s_pos, e_pos - 1),
			target:sub(e_pos, e_pos + 1) == '$@'
		idx, s_pos = idx + 2, e_pos + 2
		e_pos = string.find(target, '%$[@#]', s_pos, false)
	end
	if (s_pos &gt; target:len()) then idx = idx - 1
	else canvas[idx] = target:sub(s_pos) end
	return skel, canvas, idx
end


-- Populate a table by parsing a parameter string (heavy lifting for `parsing`,
-- `reinterpreting` and `evaluating`)
local function parse_parameter_string (tbl, str, isp, ipl, psp, ppl, trn, tru)
	local key, val, spos1, spos2, pos1, pos2
	local pos3, idx, lenplone = 0, 1, #str + 1
	if isp == nil or isp == '' then
		if psp == nil or psp == '' then
			if tru then tbl[idx] = str:match'^%s*(.-)%s*$'
			else tbl[idx] = str end
			return
		end
		spos1, spos2 = str:find(psp, 1, ppl)
		if spos1 == nil then
			key = idx
			if tru then val = str:match'^%s*(.-)%s*$'
			else val = str end
		else
			key = get_param_name(str:sub(1, spos1 - 1))
			val = str:sub(spos2 + 1)
			if trn then val = val:match'^%s*(.-)%s*$' end
		end
		tbl[key] = val
		return
	end
	if psp == nil or psp == '' then
		repeat
			pos1 = pos3 + 1
			pos2, pos3 = str:find(isp, pos1, ipl)
			val = str:sub(pos1, (pos2 or lenplone) - 1)
			if tru then val = val:match'^%s*(.-)%s*$' end
			tbl[idx], idx = val, idx + 1
		until pos2 == nil
		return
	end
	repeat
		pos1 = pos3 + 1
		pos2, pos3 = str:find(isp, pos1, ipl)
		val = str:sub(pos1, (pos2 or lenplone) - 1)
		spos1, spos2 = val:find(psp, 1, ppl)
		if spos1 == nil then
			key = idx
			if tru then val = val:match'^%s*(.-)%s*$' end
			idx = idx + 1
		else
			key = get_param_name(val:sub(1, spos1 - 1))
			val = val:sub(spos2 + 1)
			if trn then val = val:match'^%s*(.-)%s*$' end
		end
		tbl[key] = val
	until pos2 == nil
	return
end


-- Heavy lifting for `snapshotting` and `remembering`
local function make_child (ctx, src, whoami)
	local len = tonumber(ctx.pipe[ctx.fnpos + 1])
	if len == nil or len == 0 then
		local stack = new_substack(ctx)
		for key, val in pairs(src) do stack[key] = val end
		return len == nil and 1 or 2
	end
	if len &lt; 0 or math.floor(len) ~= len then error(modulename .. ', ‘' ..
		whoami .. '’: The number of parameters to copy must be an integer greater than zero', 0) end
	copy_table_maxn(new_substack(ctx), src, len)
	return 2
end


-- Heavy lifting for `setting_by_flushing`, `combining` and `combining_values`
local function set_strings_from_substack (ctx, dest, whoami)
	if ctx.n_children &lt; 1 then error(modulename ..
		', ‘' .. whoami .. '’: There are no substacks to flush', 0) end
	local currsnap = ctx.n_children
	local stack = ctx.children[currsnap]
	for key, val in pairs(memoryslots) do
		if stack[key] ~= nil then dest[val] = stack[key] end
	end
	ctx.children[currsnap], ctx.n_children = nil, currsnap - 1
end


-- Heavy lifting for `combining` and `combining_values`
local function combine_parameters (ctx, keyval_fn, whoami)
	-- NOTE: `ctx.params` might be the original metatable! This function
	-- MUST create a copy of it before returning
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘' .. whoami .. '’: No parameter name was provided', 0) end
	local argc
	local tbl, vars = ctx.params, {}
	local sortfn, ivar0, dosort, tmp = load_sort_opt(opts[offs + 2])
	if ivar0 == 2 then
		tmp = opts[offs + 3] ~= nil and opts[offs + 3]:match'^%s*(.*%S)'
	end
	ivar0 = ivar0 + offs
	if tmp == 'with_flushed_glue' then
		ivar0 = ivar0 + 1
		argc = set_strings_from_opts(vars, opts, ivar0 + 1)
		set_strings_from_substack(ctx, vars, whoami)
	else
		if tmp == 'without_flushed_glue' then ivar0 = ivar0 + 1 end
		argc = set_strings_from_opts(vars, opts, ivar0 + 1)
	end
	if argc &lt; ivar0 then error(modulename ..
		', ‘' .. whoami .. '’: No setting directive was given', 0) end
	if next(tbl) == nil then
		if vars.ifngiven ~= nil then ctx.params =
			{ [get_param_name(opts[offs + 1])] = vars.ifngiven }
		elseif tbl == ctx.oparams then ctx.params = {} end
		return argc + 1
	end
	local cache, len
	if dosort then
		local words
		cache, words, len, tmp = get_sorted_key_list(tbl, sortfn)
		for idx = 1, tmp do cache[len + idx] = words[idx] end
		len = len + tmp
	else
		cache, len = {}, 1
		for key in pairs(tbl) do cache[len], len = key, len + 1 end
		len = len - 1
	end
	local pmap, nss, kvs, pps =
		{}, 0, vars.pairsep or '', vars.itersep or ''
	for idx = 1, len do
		tmp, pmap[nss + 1] = cache[idx], pps
		pmap[nss + 2] = keyval_fn(tmp, tbl[tmp], kvs)
		nss = nss + 2
	end
	tmp = vars.oxfordsep or vars.lastsep
	if tmp ~= nil and nss &gt; 4 then pmap[nss - 1] = tmp
	elseif nss &gt; 2 and vars.lastsep ~= nil then
		pmap[nss - 1] = vars.lastsep
	end
	pmap[1] = vars.header or ''
	if vars.footer ~= nil then pmap[nss + 1] = vars.footer end
	ctx.params = { [get_param_name(opts[offs + 1])] = table.concat(pmap) }
	return argc + 1
end


-- Concatenate the numeric keys from the table of parameters to the numeric
-- keys from the table of options; non-numeric keys from the table of options
-- will prevail over colliding non-numeric keys from the table of parameters
local function concat_params (ctx, offs)
	local tbl, retval, cache, nmax = ctx.params, {}, {}, 0
	for key, val in pairs(ctx.pipe) do
		if type(key) == 'number' then
			if key &lt; 1 then cache[key] = val
			elseif key &gt; offs then cache[key - offs] = val end
			if key &gt; nmax then nmax = key end
		else cache[key] = val end
	end
	nmax = nmax - offs
	if ctx.subset == 1 then
		-- We need only the sequence
		for key, val in ipairs(tbl) do retval[key + nmax] = val end
	else
		if ctx.subset == -1 then
			for key in ipairs(tbl) do tbl[key] = nil end
		end
		for key, val in pairs(tbl) do
			if type(key) == 'number' and key &gt; 0 then
				retval[key + nmax] = val
			else retval[key] = val end
		end
	end
	for key, val in pairs(cache) do retval[key] = val end
	return retval
end


-- Flush the parameters by calling a custom function for each value (after this
-- function has been invoked `ctx.params` will be no longer usable)
local function flush_params (ctx, fn)
	local tmp
	local tbl = ctx.params
	if ctx.subset == -1 then
		for key, val in ipairs(tbl) do tbl[key] = nil end
	elseif ctx.subset == 1 then
		if ctx.pins == nil then
			for key, val in ipairs(tbl) do fn(key, val) end
			return
		end
		tmp = {}
		for key, val in ipairs(tbl) do tmp[key] = val end
		tbl = tmp
	end
	if ctx.pins ~= nil then
		local marker = ctx.sorttype &lt; 1 and ctx.subset ~= -1 or nil
		for idx = 1, #ctx.pins do
			tmp = ctx.pins[idx]
			if tbl[tmp] ~= nil then
				fn(tmp, tbl[tmp])
				tbl[tmp] = marker
			end
		end
		if ctx.subset == 1 then
			for key, val in ipairs(tbl) do
				if val ~= true then fn(key, val) end
			end
			return
		end
	end
	if ctx.sorttype &gt; 0 then
		local nums, words, nn, nw =
			get_sorted_key_list(tbl, natural_sort)
		if ctx.sorttype == 2 then
			for idx = 1, nw do fn(words[idx], tbl[words[idx]]) end
			for idx = 1, nn do fn(nums[idx], tbl[nums[idx]]) end
			return
		end
		for idx = 1, nn do fn(nums[idx], tbl[nums[idx]]) end
		for idx = 1, nw do fn(words[idx], tbl[words[idx]]) end
		return
	end
	if ctx.subset == -1 or ctx.pins == nil then
		for key, val in ipairs(tbl) do
			fn(key, val)
			tbl[key] = nil
		end
		for key, val in pairs(tbl) do fn(key, val) end
		return
	end
	for key, val in ipairs(tbl) do
		if val ~= true then fn(key, val) end
		tbl[key] = nil
	end
	for key, val in pairs(tbl) do
		if val ~= true then fn(key, val) end
	end
end


-- Flush the parameters by calling one of two custom functions for each value
-- (after this function has been invoked `ctx.params` will be no longer usable)
local function mixed_flush_params (ctx, fn_seq, fn_oth)
	if ctx.subset == 1 then
		flush_params(ctx, fn_seq)
		return
	end
	if ctx.subset == -1 then
		flush_params(ctx, fn_oth)
		return
	end
	local tbl = ctx.params
	if ctx.pins == nil and ctx.sorttype &lt; 1 then
		for key, val in ipairs(tbl) do
			fn_seq(key, val)
			tbl[key] = nil
		end
		for key, val in pairs(tbl) do fn_oth(key, val) end
		return
	end
	local tseq = {}
	for key, val in ipairs(tbl) do tseq[key] = val end
	if ctx.pins ~= nil then
		local tmp
		local marker = ctx.sorttype &lt; 1 or nil
		for idx = 1, #ctx.pins do
			tmp = ctx.pins[idx]
			if tseq[tmp] ~= nil then
				fn_seq(tmp, tbl[tmp])
				tbl[tmp], tseq[tmp] = nil, marker
			elseif tbl[tmp] ~= nil then
				fn_oth(tmp, tbl[tmp])
				tbl[tmp] = nil
			end
		end
	end
	if ctx.sorttype &gt; 0 then
		local nums, words, nn, nw =
			get_sorted_key_list(tbl, natural_sort)
		if ctx.sorttype == 2 then
			for idx = 1, nw do
				fn_oth(words[idx], tbl[words[idx]])
			end
		end
		for idx = 1, nn do
			if tseq[nums[idx]] ~= nil then
				fn_seq(nums[idx], tseq[nums[idx]])
			else fn_oth(nums[idx], tbl[nums[idx]]) end
		end
		if ctx.sorttype ~= 2 then
			for idx = 1, nw do
				fn_oth(words[idx], tbl[words[idx]])
			end
		end
		return
	end
	for key, val in ipairs(tseq) do
		if val ~= true then
			fn_seq(key, val)
			tbl[key] = nil
		end
	end
	for key, val in pairs(tbl) do fn_oth(key, val) end
end


-- Finalize and return a concatenated list
local function finalize_and_return_concatenated_list (ctx, lst, len, modsize)
	if len &gt; 0 then
		local tmp = ctx.oxfordsep or ctx.lastsep
		if tmp ~= nil and len &gt; modsize * 2 then
			lst[len - modsize + 1] = tmp
		elseif len &gt; modsize and ctx.lastsep ~= nil then
			lst[len - modsize + 1] = ctx.lastsep
		end
		lst[1] = ctx.header or ''
		if ctx.footer ~= nil then lst[len + 1] = ctx.footer end
		ctx.text = table.concat(lst)
	else ctx.text = ctx.ifngiven or '' end
end


	---                                        ---
	---     PUBLIC ENVIRONMENT                 ---
	---    ________________________________    ---
	---                                        ---


	--[[ Modifiers ]]--
	-------------------


-- Syntax:  #invoke:params|sequential|pipe to
library.sequential = function (ctx)
	if ctx.subset == 1 then error(modulename ..
		': The ‘sequential’ directive has been provided more than once', 0) end
	if ctx.subset == -1 then error(modulename ..
		': The two directives ‘non-sequential’ and ‘sequential’ are in contradiction with each other', 0) end
	if ctx.sorttype &gt; 0 then error(modulename ..
		': The ‘all_sorted’ and ‘reassorted’ directives are redundant when followed by ‘sequential’', 0) end
	ctx.iterfunc, ctx.subset = ipairs, 1
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|non-sequential|pipe to
library['non-sequential'] = function (ctx)
	if ctx.subset == -1 then error(modulename ..
		': The ‘non-sequential’ directive has been provided more than once', 0) end
	if ctx.subset == 1 then error(modulename ..
		': The two directives ‘sequential’ and ‘non-sequential’ are in contradiction with each other', 0) end
	ctx.iterfunc, ctx.subset = pairs, -1
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|all_sorted|pipe to
library.all_sorted = function (ctx)
	if ctx.sorttype == 1 then error(modulename ..
		': The ‘all_sorted’ directive has been provided more than once', 0) end
	if ctx.subset == 1 then error(modulename ..
		': The ‘all_sorted’ directive is redundant after ‘sequential’', 0) end
	if ctx.sorttype == 2 then error(modulename ..
		': The two directives ‘reassorted’ and ‘sequential’ are in contradiction with each other', 0) end
	ctx.sorttype = 1
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|reassorted|pipe to
library.reassorted = function (ctx)
	if ctx.sorttype == 2 then error(modulename ..
		': The ‘reassorted’ directive has been provided more than once', 0) end
	if ctx.subset == 1 then error(modulename ..
		': The ‘reassorted’ directive is redundant after ‘sequential’', 0) end
	if ctx.sorttype == 1 then error(modulename ..
		': The two directives ‘sequential’ and ‘reassorted’ are in contradiction with each other', 0) end
	ctx.sorttype = 2
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|pinned_until|sentinel|[parameter name 1]|[parameter
--            name 2]|...|parameter name N|sentinel|pipe to
library.pinned_until = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘pinned_until’: No sentinel was provided', 0) end
	local tmp, bucket, curr, ncurr
	local sntl, idx = opts[offs + 1]:match'^%s*(.-)%s*$', 2
	if ctx.pin_bucket == nil then
		bucket, curr, ncurr = {}, {}, 0
		ctx.pin_bucket, ctx.pins = bucket, curr
	else bucket, curr, ncurr = ctx.pin_bucket, ctx.pins, ctx.npins end
	while opts[offs + idx] ~= nil do
		tmp = opts[offs + idx]:match'^%s*(.-)%s*$'
		if tmp == sntl then
			if idx == 2 then error(modulename ..
				', ‘pinned_until’: No parameters to pin were provided', 0) end
			ctx.npins = ncurr + idx - 2
			return context_iterate(ctx, offs + idx + 1)
		end
		if tmp == '0' or tmp:find'^%-?[1-9]%d*$' ~= nil then
			tmp = tonumber(tmp)
		end
		if bucket[tmp] then error(modulename ..
			', ‘pinned_until’: Duplicate pinned parameter ‘' .. tostring(tmp) .. '’', 0) end
		curr[ncurr + idx - 1], bucket[tmp], idx = tmp, true, idx + 1
	end
	error(modulename .. ', ‘pinned_until’: Missing sentinel in position #' .. tostring(idx), 0)
end


-- Syntax:  #invoke:params|setting|directives|...|pipe to
library.setting = function (ctx)
	local new_offs = set_strings_from_opts(ctx, ctx.pipe, ctx.fnpos + 1)
	if new_offs - ctx.fnpos &lt; 2 then error(modulename ..
		', ‘setting’: No directive was given', 0) end
	return context_iterate(ctx, new_offs + 1)
end


-- Syntax:  #invoke:params|scoring|new parameter name|[container]|pipe to
library.scoring = function (ctx)
	local opts, offs, retval = ctx.pipe, ctx.fnpos, 0
	if opts[offs + 1] == nil then error(modulename ..
		', ‘scoring’: No parameter name was provided', 0) end
	for _ in pairs(ctx.params) do retval = retval + 1 end
	local tn = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if tn == 'in_substack' then
		new_substack(ctx)[get_param_name(opts[offs + 1])] =
			tostring(retval)
		return context_iterate(ctx, offs + 3)
	end
	ctx.params[get_param_name(opts[offs + 1])] = tostring(retval)
	return tn == 'here' and context_iterate(ctx, offs + 3) or
		context_iterate(ctx, offs + 2, tn)
end


-- Syntax:  #invoke:params|squeezing|pipe to
library.squeezing = function (ctx)
	local store, indices, tbl, newlen = {}, {}, ctx.params, 0
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			newlen = newlen + 1
			indices[newlen], store[key], tbl[key] = key, val, nil
		end
	end
	table.sort(indices)
	for idx = 1, newlen do tbl[idx] = store[indices[idx]] end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|filling_the_gaps|pipe to
library.filling_the_gaps = function (ctx)
	local newval, tbl, tmp, nmin, nmax, nnums =
		ctx.pipe[ctx.fnpos + 1], ctx.params, {}, 1, nil, -1
	if newval == nil then error(modulename ..
		', ‘filling_the_gaps’: No value was provided', 0) end
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			if nmax == nil then
				if key &lt; nmin then nmin = key end
				nmax = key
			elseif key &gt; nmax then nmax = key
			elseif key &lt; nmin then nmin = key end
			tmp[key], nnums = val, nnums + 1
		end
	end
	if nmax ~= nil and nmax - nmin &gt; nnums then
		ctx.n_available = ctx.n_available + nmin + nnums - nmax
		if ctx.n_available &lt; 0 then error(modulename ..
			', ‘filling_the_gaps’: It is possible to fill at most ' .. tostring(maxfill) .. ' parameters', 0) end
		for idx = nmin, nmax do tbl[idx] = newval end
		for key, val in pairs(tmp) do tbl[key] = val end
	end
	return context_iterate(ctx, ctx.fnpos + 2)
end


-- Syntax:  #invoke:params|clearing|pipe to
library.clearing = function (ctx)
	local tbl, numerics = ctx.params, {}
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			numerics[key], tbl[key] = val, nil
		end
	end
	for key, val in ipairs(numerics) do tbl[key] = val end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|cutting|left cut|right cut|pipe to
library.cutting = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local lcut = tonumber(opts[offs + 1])
	if lcut == nil or math.floor(lcut) ~= lcut then error(modulename ..
		', ‘cutting’: Left cut must be an integer number', 0) end
	local rcut = tonumber(opts[offs + 2])
	if rcut == nil or math.floor(rcut) ~= rcut then error(modulename ..
		', ‘cutting’: Right cut must be an integer number', 0) end
	local tbl = ctx.params
	local len = #tbl
	if lcut &lt; 0 then lcut = len + lcut end
	if rcut &lt; 0 then rcut = len + rcut end
	local tot = lcut + rcut
	if tot &gt; 0 then
		local cache = {}
		if tot &gt;= len then
			for key in ipairs(tbl) do tbl[key] = nil end
			tot = len
		else
			for idx = len - rcut + 1, len do tbl[idx] = nil end
			for idx = 1, lcut do tbl[idx] = nil end
		end
		for key, val in pairs(tbl) do
			if type(key) == 'number' and key &gt; 0 then
				if key &gt; len then cache[key - tot] = val
				else cache[key - lcut] = val end
				tbl[key] = nil
			end
		end
		for key, val in pairs(cache) do tbl[key] = val end
	end
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|cropping|left crop|right crop|pipe to
library.cropping = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local lcut = tonumber(opts[offs + 1])
	if lcut == nil or math.floor(lcut) ~= lcut then error(modulename ..
		', ‘cropping’: Left crop must be an integer number', 0) end
	local rcut = tonumber(opts[offs + 2])
	if rcut == nil or math.floor(rcut) ~= rcut then error(modulename ..
		', ‘cropping’: Right crop must be an integer number', 0) end
	local tbl = ctx.params
	local nmin, nmax
	for key in pairs(tbl) do
		if type(key) == 'number' then
			if nmin == nil then nmin, nmax = key, key
			elseif key &gt; nmax then nmax = key
			elseif key &lt; nmin then nmin = key end
		end
	end
	if nmin ~= nil then
		local len = nmax - nmin + 1
		if lcut &lt; 0 then lcut = len + lcut end
		if rcut &lt; 0 then rcut = len + rcut end
		if lcut + rcut - len &gt; -1 then
			for key in pairs(tbl) do
				if type(key) == 'number' then tbl[key] = nil end
			end
		elseif lcut + rcut &gt; 0 then
			for idx = nmax - rcut + 1, nmax do tbl[idx] = nil end
			for idx = nmin, nmin + lcut - 1 do tbl[idx] = nil end
			local lshift = nmin + lcut - 1
			if lshift &gt; 0 then
				for idx = lshift + 1, nmax do
					tbl[idx - lshift], tbl[idx] =
						tbl[idx], nil
				end
			end
		end
	end
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|purging|start offset|length|pipe to
library.purging = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local idx = tonumber(opts[offs + 1])
	if idx == nil or math.floor(idx) ~= idx then error(modulename ..
		', ‘purging’: Start offset must be an integer number', 0) end
	local len = tonumber(opts[offs + 2])
	if len == nil or math.floor(len) ~= len then error(modulename ..
		', ‘purging’: Length must be an integer number', 0) end
	local tbl = ctx.params
	if len &lt; 1 then
		len = len + table.maxn(tbl)
		if idx &gt; len then return context_iterate(ctx, offs + 3) end
		len = len - idx + 1
	end
	ctx.params = copy_table_reduced(tbl, idx, len)
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|backpurging|start offset|length|pipe to
library.backpurging = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local last = tonumber(opts[offs + 1])
	if last == nil or math.floor(last) ~= last then error(modulename ..
		', ‘backpurging’: Start offset must be an integer number', 0) end
	local len = tonumber(opts[offs + 2])
	if len == nil or math.floor(len) ~= len then error(modulename ..
		', ‘backpurging’: Length must be an integer number', 0) end
	local idx
	local tbl = ctx.params
	if len &gt; 0 then idx = last - len + 1
	else
		for key in pairs(tbl) do
			if type(key) == 'number' and (idx == nil or
				key &lt; idx) then idx = key end
		end
		if idx == nil then return context_iterate(ctx, offs + 3) end
		idx = idx - len
		if last &lt; idx then return context_iterate(ctx, offs + 3) end
		len = last - idx + 1
	end
	ctx.params = copy_table_reduced(ctx.params, idx, len)
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|shifting|addend|pipe to
library.shifting = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local nshift = tonumber(ctx.pipe[ctx.fnpos + 1])
	if nshift == nil or nshift == 0 or math.floor(nshift) ~= nshift then
		error(modulename .. ', ‘shifting’: A non-zero integer number must be provided', 0) end
	local tbl = {}
	for key, val in pairs(ctx.params) do
		if type(key) == 'number' then tbl[key + nshift] = val
		else tbl[key] = val end
	end
	ctx.params = tbl
	return context_iterate(ctx, ctx.fnpos + 2)
end


-- Syntax:  #invoke:params|reversing_numeric_names|pipe to
library.reversing_numeric_names = function (ctx)
	local tbl, numerics, nmax = ctx.params, {}, 0
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			numerics[key], tbl[key] = val, nil
			if key &gt; nmax then nmax = key end
		end
	end
	for key, val in pairs(numerics) do tbl[nmax - key + 1] = val end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|pivoting_numeric_names|pipe to
--[[
library.pivoting_numeric_names = function (ctx)
	local tbl = ctx.params
	local shift = #tbl + 1
	if shift &lt; 2 then return library.reversing_numeric_names(ctx) end
	local tmp = {}
	for key, val in pairs(tbl) do
		if type(key) == 'number' then tmp[key], tbl[key] = val, nil end
	end
	for key, val in pairs(tmp) do tbl[shift - key] = val end
	return context_iterate(ctx, ctx.fnpos + 1)
end
]]--


-- Syntax:  #invoke:params|mirroring_numeric_names|pipe to
--[[
library.mirroring_numeric_names = function (ctx)
	local nmax, nmin
	local tbl, tmp = ctx.params, {}
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			tmp[key], tbl[key] = val, nil
			if nmax == nil then nmin, nmax = key, key
			elseif key &gt; nmax then nmax = key
			elseif key &lt; nmin then nmin = key end
		end
	end
	for key, val in pairs(tmp) do tbl[nmax + nmin - key] = val end
	return context_iterate(ctx, ctx.fnpos + 1)
end
]]--


-- Syntax:  #invoke:params|swapping_numeric_names|pipe to
--[[
library.swapping_numeric_names = function (ctx)
	local tmp
	local tbl, cache, nsize = ctx.params, {}, 1
	for key in pairs(tbl) do
		if type(key) == 'number' then
			cache[nsize], nsize = key, nsize + 1
		end
	end
	table.sort(cache)
	for idx = math.floor((nsize - 1) / 2), 1, -1 do
		tmp = tbl[cache[idx] ]
		tbl[cache[idx] ] = tbl[cache[nsize - idx] ]
		tbl[cache[nsize - idx] ] = tmp
	end
	return context_iterate(ctx, ctx.fnpos + 1)
end
]]--


-- Syntax:  #invoke:params|sorting_sequential_values|[criterion]|pipe to
library.sorting_sequential_values = function (ctx)
	local sortfn
	local opts, offs = ctx.pipe, ctx.fnpos
	local tn = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tn ~= nil then sortfn = sortfunctions[tn] end
	if sortfn then table.sort(ctx.params, sortfn)
	else table.sort(ctx.params) end -- i.e. either `false` or `nil`
	if sortfn == nil then return context_iterate(ctx, offs + 1, tn) end
	return context_iterate(ctx, offs + 2)
end


-- Syntax:  #invoke:params|splicing|[add to position]|position|increment|
--            [number of elements to write]|...|pipe to
library.splicing = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local tmp2, argc, pos, refp
	local tbl, opts, offs = ctx.params, ctx.pipe, ctx.fnpos
	local tmp1 = opts[offs + 1]
	if tmp1 ~= nil then
		tmp2 = tonumber(tmp1)
		if tmp2 == nil or math.floor(tmp2) ~= tmp2 then
			pos, argc, tmp2 = tonumber(opts[offs + 2]), offs + 4,
				tmp1:match'^%s*(.*%S)'
			if tmp2 ~= nil then
				refp = position_references[tmp2]
				if refp == nil then error(modulename ..
					', ‘splicing’: ‘' .. tostring(tmp2) .. '’ is not a valid first argument', 0) end
			else refp = 0 end
		else pos, argc, refp = tmp2, offs + 3, 0 end
	else pos, argc, refp = tonumber(opts[offs + 2]), offs + 4, 0 end
	if pos == nil or math.floor(pos) ~= pos then error(modulename ..
		', ‘splicing’: The position must be an integer number', 0) end
	local len = tonumber(opts[argc - 1])
	if len == nil or math.floor(len) ~= len then error(modulename ..
		', ‘splicing’: The increment must be an integer number', 0) end
	local insn = tonumber(opts[argc])
	if len == 0 and (insn == nil or insn &lt; 1) then error(modulename ..
		', ‘splicing’: When the increment is zero the number of elements to write cannot be zero', 0) end
	if refp == 2 then
		for _ in ipairs(tbl) do pos = pos + 1 end
		refp = 0
	end
	tmp1, tmp2 = nil, nil
	if refp ~= 0 or len ~= 0 then
		for key, val in pairs(tbl) do
			if type(key) == 'number' then
				if tmp1 == nil then tmp1, tmp2 = key, key
				elseif key &lt; tmp1 then tmp1 = key
				elseif key &gt; tmp2 then tmp2 = key end
			end
		end
	end
	if tmp2 == nil then len = 0
	elseif refp == 3 then pos = pos + tmp2
	elseif refp == 1 then pos = pos + tmp1 end
	if len &gt; 0 and pos + len &gt; tmp1 and pos &lt;= tmp2 then
		tbl = copy_table_expanded(tbl, pos, len)
	elseif len &lt; 0 and pos - len &gt; tmp1 and pos &lt;= tmp2 then
		tbl = copy_table_reduced(tbl, pos, -len)
	else tbl = copy_or_ref_table(tbl, tbl ~= ctx.oparams) end
	ctx.params = tbl
	if insn == nil or insn &lt; 0 or math.floor(insn) ~= insn then
		return context_iterate(ctx, argc)
	end
	tmp1 = argc - offs - pos + 1
	for key = pos, pos + insn - 1 do tbl[key] = opts[offs + key + tmp1] end
	return context_iterate(ctx, argc + insn + 1)
end


-- Syntax:  #invoke:params|imposing|name|value|pipe to
library.imposing = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘imposing’: Missing parameter name to impose', 0) end
	ctx.params[get_param_name(opts[offs + 1])] = opts[offs + 2]
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|providing|name|value|pipe to
library.providing = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘providing’: Missing parameter name to provide', 0) end
	local key = get_param_name(opts[offs + 1])
	if ctx.params[key] == nil then ctx.params[key] = opts[offs + 2] end
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|reassigning|source|destination|[mode]|pipe to
library.reassigning = function (ctx)
	local tbl, opts, offs = ctx.params, ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘reassigning’: Missing source parameter', 0) end
	if opts[offs + 2] == nil then error(modulename ..
		', ‘reassigning’: Missing destination parameter', 0) end
	local mode, argc
	local src, tn = get_param_name(opts[offs + 1]),
		opts[offs + 3] ~= nil and opts[offs + 3]:match'^%s*(.*%S)'
	local val = tbl[src]
	if tn ~= nil then mode = a_modes[tn] end
	if mode == nil then mode, argc = 0, offs + 3
	else argc, tn = offs + 4, nil end
	if val == nil and mode &gt; 1 then
		return context_iterate(ctx, argc, tn)
	end
	local dest = get_param_name(opts[offs + 2])
	local tmp = tbl[dest] == nil
	if mode % 2 == 0 or (mode == 7 and tmp) then tbl[src] = nil end
	if tmp or mode &lt; 4 then tbl[dest] = val end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|discarding|name|[how many]|pipe to
library.discarding = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘discarding’: Missing parameter name to discard', 0) end
	local len = tonumber(opts[offs + 2])
	if len == nil then
		ctx.params[get_param_name(opts[offs + 1])] = nil
		return context_iterate(ctx, offs + 2)
	end
	local key = tonumber(opts[offs + 1])
	if key == nil or math.floor(key) ~= key then error(modulename ..
		', ‘discarding’: A range was provided, but the initial parameter name is not an integer number', 0) end
	if len &lt; 1 or math.floor(len) ~= len then error(modulename ..
		', ‘discarding’: A range can only be an integer number greater than zero', 0) end
	for idx = key, key + len - 1 do ctx.params[idx] = nil end
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|excluding_non-numeric_names|pipe to
library['excluding_non-numeric_names'] = function (ctx)
	local tmp = ctx.params
	for key, val in pairs(tmp) do
		if type(key) ~= 'number' then tmp[key] = nil end
	end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|excluding_numeric_names|pipe to
library.excluding_numeric_names = function (ctx)
	local tmp = ctx.params
	for key, val in pairs(tmp) do
		if type(key) == 'number' then tmp[key] = nil end
	end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|with_name_matching|target 1|[plain flag 1]|[or]|
--            [target 2]|[plain flag 2]|[or]|[...]|[target N]|[plain flag
--            N]|pipe to
library.with_name_matching = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local tmp, ptn
	local tbl, newparams, opts, offs = ctx.params, {}, ctx.pipe, ctx.fnpos
	local targets, nptns, argc, tn = load_pattern_args(opts, offs,
		'with_name_matching')
	for idx = 1, nptns do
		ptn = targets[idx]
		if ptn[3] then
			tmp = ptn[1]
			if tmp == '0' or tmp:find'^%-?[1-9]%d*$' ~= nil then
				tmp = tonumber(tmp)
			end
			newparams[tmp] = tbl[tmp]
		else
			for key, val in pairs(tbl) do
				if tostring(key):find(ptn[1], 1, ptn[2]) then
					newparams[key] = val
				end
			end
		end
	end
	ctx.params = newparams
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|with_name_not_matching|target 1|[plain flag 1]|
--            [and]|[target 2]|[plain flag 2]|[and]|[...]|[target N]|[plain
--            flag N]|pipe to
library.with_name_not_matching = function (ctx)
	local tbl, opts, offs = ctx.params, ctx.pipe, ctx.fnpos
	local targets, nptns, argc, tn = load_pattern_args(opts, offs,
		'with_name_not_matching')
	if nptns == 1 and targets[1][3] then
		local tmp = targets[1][1]
		if tmp == '0' or tmp:find'^%-?[1-9]%d*$' ~= nil then
			tbl[tonumber(tmp)] = nil
		else tbl[tmp] = nil end
		return context_iterate(ctx, argc, tn)
	end
	local yesmatch, ptn
	for key in pairs(tbl) do
		yesmatch = true
		for idx = 1, nptns do
			ptn = targets[idx]
			if ptn[3] then
				if tostring(key) ~= ptn[1] then
					yesmatch = false
					break
				end
			elseif not tostring(key):find(ptn[1], 1, ptn[2]) then
				yesmatch = false
				break
			end
		end
		if yesmatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|with_value_matching|target 1|[plain flag 1]|[or]|
--            [target 2]|[plain flag 2]|[or]|[...]|[target N]|[plain flag
--            N]|pipe to
library.with_value_matching = function (ctx)
	local nomatch, ptn
	local tbl, opts, offs = ctx.params, ctx.pipe, ctx.fnpos
	local targets, nptns, argc, tn = load_pattern_args(opts, offs,
		'with_value_matching')
	for key, val in pairs(tbl) do
		nomatch = true
		for idx = 1, nptns do
			ptn = targets[idx]
			if ptn[3] then
				if val == ptn[1] then
					nomatch = false
					break
				end
			elseif val:find(ptn[1], 1, ptn[2]) then
				nomatch = false
				break
			end
		end
		if nomatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|with_value_not_matching|target 1|[plain flag 1]|
--            [and]|[target 2]|[plain flag 2]|[and]|[...]|[target N]|[plain
--            flag N]|pipe to
library.with_value_not_matching = function (ctx)
	local yesmatch, ptn
	local tbl, opts, offs = ctx.params, ctx.pipe, ctx.fnpos
	local targets, nptns, argc, tn = load_pattern_args(opts, offs,
		'with_value_not_matching')
	for key, val in pairs(tbl) do
		yesmatch = true
		for idx = 1, nptns do
			ptn = targets[idx]
			if ptn[3] then
				if val ~= ptn[1] then
					yesmatch = false
					break
				end
			elseif not val:find(ptn[1], 1, ptn[2]) then
				yesmatch = false
				break
			end
		end
		if yesmatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|keeping_at_most|number of parameters to pick|pipe to
library.keeping_at_most = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local len = tonumber(ctx.pipe[ctx.fnpos + 1])
	if len == nil or len &lt; 1 or math.floor(len) ~= len then error(modulename ..
		', ‘keeping_at_most’: The number of parameters to keep must be an integer greater than zero', 0) end
	ctx.params = copy_table_maxn({}, ctx.params, len)
	return context_iterate(ctx, ctx.fnpos + 2)
end


-- Syntax:  #invoke:params|trimming_values|pipe to
library.trimming_values = function (ctx)
	local tbl = ctx.params
	for key, val in pairs(tbl) do tbl[key] = val:match'^%s*(.-)%s*$' end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|mapping_to_lowercase|pipe to
library.mapping_to_lowercase = function (ctx)
	local tbl = ctx.params
	for key, val in pairs(tbl) do tbl[key] = val:lower() end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|mapping_to_uppercase|pipe to
library.mapping_to_uppercase = function (ctx)
	local tbl = ctx.params
	for key, val in pairs(tbl) do tbl[key] = val:upper() end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|mapping_by_calling|template name|[call
--            style]|[let/use]|[...]|[let/use]|[...]|[number of additional
--            parameters]|[parameter 1]|[parameter 2]|[...]|[parameter N]|pipe to
library.mapping_by_calling = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local tname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tname == nil then error(modulename ..
		', ‘mapping_by_calling’: No template name was provided', 0) end
	local margs, argc, looptype, karg, varg, tbl, mem =
		load_callback_opts(opts, offs + 1, mapping_styles.values_only,
			ctx.params)
	local model = { title = tname, args = margs }
	value_maps[looptype](tbl, margs, karg, varg, function ()
		return ctx.frame:expandTemplate(model)
	end)
	for key, val in pairs(mem) do tbl[key] = val end
	ctx.params = tbl
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_invoking|module name|function name|[call
--            style]|[let/use]|[...]|[let/use]|[...]|[number of additional
--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to
library.mapping_by_invoking = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local mname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if mname == nil then error(modulename ..
		', ‘mapping_by_invoking’: No module name was provided', 0) end
	local fname = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		', ‘mapping_by_invoking’: No function name was provided', 0) end
	local margs, argc, looptype, karg, varg, tbl, mem =
		load_callback_opts(opts, offs + 2, mapping_styles.values_only,
			ctx.params)
	local model = { title = 'Module:' .. mname, args = margs }
	local mfunc = require(model.title)[fname]
	if mfunc == nil then error(modulename ..
		', ‘mapping_by_invoking’: The function ‘' .. fname .. '’ does not exist', 0) end
	value_maps[looptype](tbl, margs, karg, varg, function ()
		return tostring(mfunc(ctx.frame:newChild(model)))
	end)
	for key, val in pairs(mem) do tbl[key] = val end
	ctx.params = tbl
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_magic|parser function|[call
--            style]|[let/use]|[...]|[let/use]|[...]|[number of additional
--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to
library.mapping_by_magic = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local magic = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if magic == nil then error(modulename ..
		', ‘mapping_by_magic’: No parser function was provided', 0) end
	local margs, argc, looptype, karg, varg, tbl, mem =
		load_callback_opts(opts, offs + 1, mapping_styles.values_only,
			ctx.params)
	value_maps[looptype](tbl, margs, karg, varg, function ()
		return ctx.frame:callParserFunction(magic, margs)
	end)
	for key, val in pairs(mem) do tbl[key] = val end
	ctx.params = tbl
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_replacing|target|replace|[count]|[plain
--            flag]|pipe to
library.mapping_by_replacing = function (ctx)
	local ptn, repl, nmax, flg, argc, die, tn =
		load_replace_args(ctx.pipe, ctx.fnpos, 'mapping_by_replacing')
	if die then return context_iterate(ctx, argc, tn) end
	local tbl = ctx.params
	if flg == 3 then
		for key, val in pairs(tbl) do
			if val == ptn then tbl[key] = repl end
		end
	else
		if flg == 2 then
			-- Copied from Module:String's `str._escapePattern()`
			ptn = ptn:gsub('[%(%)%.%%%+%-%*%?%[%^%$%]]', '%%%0')
		end
		for key, val in pairs(tbl) do
			tbl[key] = val:gsub(ptn, repl, nmax)
		end
	end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|mapping_by_mixing|mixing string|pipe to
library.mapping_by_mixing = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘mapping_by_mixing’: No mixing string was provided', 0) end
	local tbl, mix = ctx.params, opts[offs + 1]
	if mix == '$#' then
		for key in pairs(tbl) do tbl[key] = tostring(key) end
		return context_iterate(ctx, offs + 2)
	end
	local skel, cnv, n_parts = parse_placeholder_string(mix)
	for key, val in pairs(tbl) do
		for idx = 2, n_parts, 2 do
			if skel[idx] then cnv[idx] = val
			else cnv[idx] = tostring(key) end
		end
		tbl[key] = table.concat(cnv)
	end
	return context_iterate(ctx, offs + 2)
end


-- Syntax:  #invoke:params|renaming_to_lowercase|pipe to
library.renaming_to_lowercase = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache = {}
	for key, val in pairs(ctx.params) do
		if type(key) == 'string' then cache[key:lower()] = val else
		cache[key] = val end
	end
	ctx.params = cache
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|renaming_to_uppercase|pipe to
library.renaming_to_uppercase = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache = {}
	for key, val in pairs(ctx.params) do
		if type(key) == 'string' then cache[key:upper()] = val else
		cache[key] = val end
	end
	ctx.params = cache
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|renaming_to_sequence|[sort order]|pipe to
library.renaming_to_sequence = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache, len
	local tbl = ctx.params
	local sortfn, argc, dosort, tn = load_sort_opt(ctx.pipe[ctx.fnpos + 1])
	if dosort then
		local words, wl
		cache, words, len, wl = get_sorted_key_list(tbl, sortfn)
		for idx = 1, len do cache[idx] = tbl[cache[idx]] end
		for idx = 1, wl do cache[len + idx] = tbl[words[idx]] end
	else
		cache, len = {}, 1
		for _, val in pairs(tbl) do cache[len], len = val, len + 1 end
	end
	ctx.params = cache
	return context_iterate(ctx, ctx.fnpos + argc, tn)
end


-- Syntax:  #invoke:params|renaming_by_calling|template name|[call
--            style]|[let/use]|[...]|[let/use]|[...]|[number of additional
--            parameters]|[parameter 1]|[parameter 2]|[...]|[parameter N]|pipe to
library.renaming_by_calling = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local tname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tname == nil then error(modulename ..
		', ‘renaming_by_calling’: No template name was provided', 0) end
	local rargs, argc, looptype, karg, varg, tbl, mem =
		load_callback_opts(opts, offs + 1, mapping_styles.names_only,
			ctx.params)
	local model = { title = tname, args = rargs }
	map_names(tbl, rargs, karg, varg, looptype, function ()
		return ctx.frame:expandTemplate(model)
	end)
	for key, val in pairs(mem) do tbl[key] = val end
	ctx.params = tbl
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_invoking|module name|function
--            name|[call style]|[let/use]|[...]|[let/use]|[...]|[number of
--            additional arguments]|[argument 1]|[argument 2]|[...]|[argument
--            N]|pipe to
library.renaming_by_invoking = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local mname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if mname == nil then error(modulename ..
		', ‘renaming_by_invoking’: No module name was provided', 0) end
	local fname = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		', ‘renaming_by_invoking’: No function name was provided', 0) end
	local rargs, argc, looptype, karg, varg, tbl, mem =
		load_callback_opts(opts, offs + 2, mapping_styles.names_only,
			ctx.params)
	local model = { title = 'Module:' .. mname, args = rargs }
	local mfunc = require(model.title)[fname]
	if mfunc == nil then error(modulename ..
		', ‘renaming_by_invoking’: The function ‘' .. fname .. '’ does not exist', 0) end
	map_names(tbl, rargs, karg, varg, looptype, function ()
		return tostring(mfunc(ctx.frame:newChild(model)))
	end)
	for key, val in pairs(mem) do tbl[key] = val end
	ctx.params = tbl
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_magic|parser function|[call
--            style]|[let/use]|[...]|[let/use]|[...]|[number of additional
--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to
library.renaming_by_magic = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local magic = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if magic == nil then error(modulename ..
		', ‘renaming_by_magic’: No parser function was provided', 0) end
	local rargs, argc, looptype, karg, varg, tbl, mem =
		load_callback_opts(opts, offs + 1, mapping_styles.names_only,
			ctx.params)
	map_names(tbl, rargs, karg, varg, looptype, function ()
		return ctx.frame:callParserFunction(magic, rargs)
	end)
	for key, val in pairs(mem) do tbl[key] = val end
	ctx.params = tbl
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_replacing|target|replace|[count]|[plain
--            flag]|pipe to
library.renaming_by_replacing = function (ctx)
	local ptn, repl, nmax, flg, argc, die, tn =
		load_replace_args(ctx.pipe, ctx.fnpos, 'renaming_by_replacing')
	if die then return context_iterate(ctx, argc, tn) end
	local tbl = ctx.params
	if flg == 3 then
		ptn = get_param_name(ptn)
		local val = tbl[ptn]
		if val ~= nil then
			tbl[ptn], tbl[get_param_name(repl)] = nil, val
		end
	else
		if flg == 2 then
			-- Copied from Module:String's `str._escapePattern()`
			ptn = ptn:gsub('[%(%)%.%%%+%-%*%?%[%^%$%]]', '%%%0')
		end
		local cache = {}
		for key, val in pairs(tbl) do
			steal_if_renamed(val, tbl, key, cache,
				tostring(key):gsub(ptn, repl, nmax))
		end
		for key, val in pairs(cache) do tbl[key] = val end
	end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|renaming_by_mixing|mixing string|pipe to
library.renaming_by_mixing = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local mix = ctx.pipe[ctx.fnpos + 1]
	if mix == nil then error(modulename ..
		', ‘renaming_by_mixing’: No mixing string was provided', 0) end
	local cache = {}
	mix = mix:match'^%s*(.-)%s*$'
	if mix == '$@' then
		for _, val in pairs(ctx.params) do
			cache[get_param_name(val)] = val
		end
	else
		local skel, canvas, n_parts = parse_placeholder_string(mix)
		for key, val in pairs(ctx.params) do
			for idx = 2, n_parts, 2 do
				if skel[idx] then canvas[idx] = val
				else canvas[idx] = tostring(key) end
			end
			cache[get_param_name(table.concat(canvas))] = val
		end
	end
	ctx.params = cache
	return context_iterate(ctx, ctx.fnpos + 2)
end


-- Syntax:  #invoke:params|grouping_by_calling|template
--            name|[let/use]|[...]|[let/use]|[...]|[number of additional
--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to
library.grouping_by_calling = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts, offs = ctx.pipe, ctx.fnpos
	local tmp, argc, tbl, mem =
		load_child_opts(opts, offs + 2, 0, ctx.params)
	local gargs = {}
	for key, val in pairs(tmp) do
		if type(key) == 'number' and key &lt; 1 then gargs[key - 1] = val
		else gargs[key] = val end
	end
	tmp = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tmp == nil then error(modulename ..
		', ‘grouping_by_calling’: No template name was provided', 0) end
	local model = { title = tmp }
	local groups = make_groups(tbl)
	for gid, group in pairs(groups) do
		for key, val in pairs(gargs) do group[key] = val end
		group[0], model.args = gid, group
		groups[gid] = ctx.frame:expandTemplate(model)
	end
	for key, val in pairs(mem) do groups[key] = val end
	ctx.params = groups
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|parsing|string to parse|[trim flag]|[iteration
--            delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe to
library.parsing = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘parsing’: No string to parse was provided', 0) end
	local isep, iplain, psep, pplain, trimnamed, trimunnamed, argc, tn =
		load_parse_opts(opts, offs + 2, '|', '=')
	parse_parameter_string(ctx.params, opts[offs + 1], isep, iplain, psep,
		pplain, trimnamed, trimunnamed)
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|reinterpreting|parameter to reinterpret|[trim
--            flag]|[iteration delimiter setter]|[...]|[key-value delimiter
--            setter]|[...]|pipe to
library.reinterpreting = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘reinterpreting’: No parameter to reinterpret was provided', 0) end
	local isep, iplain, psep, pplain, trimnamed, trimunnamed, argc, tn =
		load_parse_opts(opts, offs + 2, '|', '=')
	local tbl, tmp = ctx.params, get_param_name(opts[offs + 1])
	local str = tbl[tmp]
	if str ~= nil then
		tbl[tmp] = nil
		parse_parameter_string(tbl, str, isep, iplain, psep, pplain,
			trimnamed, trimunnamed)
	end
	return context_iterate(ctx, argc, tn)
end


-- Syntax:  #invoke:params|evaluating|string to parse|[trim flag]|[iteration
--            delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe to
library.evaluating = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘evaluating’: No string to parse was provided', 0) end
	local isep, iplain, psep, pplain, trimnamed, trimunnamed, repos, tn =
		load_parse_opts(opts, offs + 2, '!', ':')
	if opts[offs + 1]:match'^%s*(.*%S)' == nil then
		remove_numeric_keys(opts, offs, repos - offs)
		return context_iterate(ctx, offs, tn)
	end
	local new_opts, cache = {}, {}
	parse_parameter_string(cache, opts[offs + 1], isep, iplain, psep,
		pplain, trimnamed, trimunnamed)
	local shift = #cache + offs - repos + 1
	for key, val in pairs(opts) do
		if type(key) ~= 'number' or key &lt; offs then new_opts[key] = val
		elseif key &gt;= repos then new_opts[key + shift] = val end
	end
	for key, val in pairs(cache) do
		if type(key) ~= 'number' or key &lt; 1 then new_opts[key] = val
		else new_opts[key + offs] = val end
	end
	ctx.pipe = new_opts
	return context_iterate(ctx, offs + 1)
end


-- Syntax:  #invoke:params|mixing_names_and_values|mixing string|pipe to
library.mixing_names_and_values = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘mixing_names_and_values’: No mixing string was provided for parameter names', 0) end
	if opts[offs + 2] == nil then error(modulename ..
		', ‘mixing_names_and_values’: No mixing string was provided for parameter values', 0) end
	local tmp
	local cache, mix_k, mix_v =
		{}, opts[offs + 1]:match'^%s*(.-)%s*$', opts[offs + 2]
	if mix_k == '$@' and mix_v == '$@' then
		for _, val in pairs(ctx.params) do
			cache[get_param_name(val)] = val
		end
	elseif mix_k == '$@' and mix_v == '$#' then
		for key, val in pairs(ctx.params) do
			cache[get_param_name(val)] = tostring(key)
		end
	elseif mix_k == '$#' and mix_v == '$#' then
		for key in pairs(ctx.params) do cache[key] = tostring(key) end
	else
		local skel_k, cnv_k, n_parts_k = parse_placeholder_string(mix_k)
		local skel_v, cnv_v, n_parts_v = parse_placeholder_string(mix_v)
		for key, val in pairs(ctx.params) do
			tmp = tostring(key)
			for idx = 2, n_parts_k, 2 do
				if skel_k[idx] then cnv_k[idx] = val
				else cnv_k[idx] = tmp end
			end
			for idx = 2, n_parts_v, 2 do
				if skel_v[idx] then cnv_v[idx] = val
				else cnv_v[idx] = tmp end
			end
			cache[get_param_name(table.concat(cnv_k))] =
				table.concat(cnv_v)
		end
	end
	ctx.params = cache
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|combining|new parameter name|[sort
--            order]|[with/without flushed glue]|setting directives|...|pipe to
library.combining = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	return context_iterate(ctx, combine_parameters(
		ctx,
		function (key, val, kvs) return key .. kvs .. val end,
		'combining'
	))
end


-- Syntax:  #invoke:params|combining_values|new parameter name|[sort
--            order]|[with/without flushed glue]|setting directives|...|pipe to
library.combining_values = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	return context_iterate(ctx, combine_parameters(
		ctx,
		function (key, val, kvs) return val end,
		'combining_values'
	))
end


-- Syntax:  #invoke:params|combining_by_calling|template name|new parameter
--            name|pipe to
library.combining_by_calling = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts, offs = ctx.pipe, ctx.fnpos
	local tname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tname == nil then error(modulename ..
		', ‘combining_by_calling’: No template name was provided', 0) end
	if opts[offs + 2] == nil then error(modulename ..
		', ‘combining_by_calling’: No parameter name was provided', 0) end
	ctx.params = {
		[get_param_name(opts[offs + 2])] = ctx.frame:expandTemplate{
			title = tname,
			args = ctx.params
		}
	}
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|combining_by_invoking|module name|function name|new
--            parameter name|pipe to
library.combining_by_invoking = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts, offs = ctx.pipe, ctx.fnpos
	local mname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if mname == nil then error(modulename ..
		', ‘combining_by_invoking’: No module name was provided', 0) end
	local fname = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		', ‘combining_by_invoking’: No function name was provided', 0) end
	if opts[offs + 3] == nil then error(modulename ..
		', ‘combining_by_invoking’: No parameter name was provided', 0) end
	local model = { title = 'Module:' .. mname, args = ctx.params }
	local mfunc = require(model.title)[fname]
	if mfunc == nil then error(modulename ..
		', ‘mapping_by_invoking’: The function ‘' .. fname .. '’ does not exist', 0) end
	ctx.params = {
		[get_param_name(opts[offs + 3])] =
			tostring(mfunc(ctx.frame:newChild(model)))
	}
	return context_iterate(ctx, offs + 4)
end


-- Syntax:  #invoke:params|combining_by_magic|parser function|new parameter
--            name|pipe to
library.combining_by_magic = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts, offs = ctx.pipe, ctx.fnpos
	local magic = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if magic == nil then error(modulename ..
		', ‘combining_by_magic’: No parser function was provided', 0) end
	if opts[offs + 2] == nil then error(modulename ..
		', ‘combining_by_magic’: No parameter name was provided', 0) end
	ctx.params = {
		[get_param_name(opts[offs + 2])] =
			ctx.frame:callParserFunction(magic, ctx.params)
	}
	return context_iterate(ctx, offs + 3)
end


-- Syntax:  #invoke:params|snapshotting|[maximum number]|pipe to
library.snapshotting = function (ctx)
	return context_iterate(ctx, ctx.fnpos +
		make_child(ctx, ctx.params, 'snapshotting'))
end


-- Syntax:  #invoke:params|remembering|[maximum number]|pipe to
library.remembering = function (ctx)
	return context_iterate(ctx, ctx.fnpos +
		make_child(ctx, ctx.oparams, 'remembering'))
end


-- Syntax:  #invoke:params|entering_substack|[new]|pipe to
library.entering_substack = function (ctx)
	local tbl, opts, offs, ncurrparent =
		ctx.params, ctx.pipe, ctx.fnpos, ctx.n_parents + 1
	local tn = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if ctx.parents == nil then ctx.parents = { tbl }
	else ctx.parents[ncurrparent] = tbl end
	ctx.n_parents = ncurrparent
	if tn == 'new' then
		ctx.params = {}
		return context_iterate(ctx, offs + 2)
	end
	local currsnap = ctx.n_children
	if currsnap &gt; 0 then
		ctx.params, ctx.children[currsnap], ctx.n_children =
			ctx.children[currsnap], nil, currsnap - 1
	else
		local newparams = {}
		for key, val in pairs(tbl) do newparams[key] = val end
		ctx.params = newparams
	end
	return context_iterate(ctx, offs + 1, tn)
end


-- Syntax:  #invoke:params|pulling|parameter name|pipe to
library.pulling = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘pulling’: No parameter to pull was provided', 0) end
	local tmp = ctx.n_parents
	local parent = tmp &lt; 1 and ctx.oparams or ctx.parents[tmp]
	tmp = get_param_name(opts[offs + 1])
	if parent[tmp] ~= nil then ctx.params[tmp] = parent[tmp] end
	return context_iterate(ctx, ctx.fnpos + 2)
end


-- Syntax:  #invoke:params|recalling|parameter name|pipe to
library.recalling = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘recalling’: No parameter to recall was provided', 0) end
	local arg = get_param_name(opts[offs + 1])
	if ctx.oparams[arg] ~= nil then ctx.params[arg] = ctx.oparams[arg] end
	return context_iterate(ctx, ctx.fnpos + 2)
end


-- Syntax:  #invoke:params|finding|parameter name|pipe to
--[[
library.finding = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘finding’: No parameter to find was provided', 0) end
	local arg = get_param_name(opts[offs + 1])
	local parent
	for idx = ctx.n_parents, 1, -1 do
		parent = ctx.parents[idx]
		if parent[arg] ~= nil then
			ctx.params[arg] = parent[arg]
			return context_iterate(ctx, offs + 2)
		end
	end
	if ctx.oparams[arg] ~= nil then ctx.params[arg] = ctx.oparams[arg] end
	return context_iterate(ctx, offs + 2)
end
]]--


-- Syntax:  #invoke:params|picking|number of parameters to pick|pipe to
--[[
library.picking = function (ctx)
	local len = tonumber(ctx.pipe[ctx.fnpos + 1])
	if len == nil or len &lt; 1 or math.floor(len) ~= len then error(modulename ..
		', ‘picking’: The number of parameters to pick must be an integer greater than zero', 0) end
	if ctx.n_parents &lt; 1 then copy_table_maxn(ctx.params, ctx.oparams, len)
	else copy_table_maxn(ctx.params, ctx.parents[ctx.n_parents], len) end
	return context_iterate(ctx, ctx.fnpos + 2)
end
]]--


-- Syntax:  #invoke:params|detaching_substack|pipe to
library.detaching_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent &lt; 1 then error(modulename ..
		', ‘detaching_substack’: No substacks have been created', 0) end
	local parent = ctx.parents[ncurrparent]
	for key in pairs(ctx.params) do parent[key] = nil end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|dropping_substack|pipe to
library.dropping_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent &lt; 1 then error(modulename ..
		', ‘dropping_substack’: No substacks have been created', 0) end
	ctx.params, ctx.parents[ncurrparent], ctx.n_parents =
		ctx.parents[ncurrparent], nil, ncurrparent - 1
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|leaving_substack|pipe to
library.leaving_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent &lt; 1 then error(modulename ..
		', ‘leaving_substack’: No substacks have been created', 0) end
	local currsnap = ctx.n_children + 1
	if ctx.children == nil then ctx.children = { ctx.params }
	else ctx.children[currsnap] = ctx.params end
	ctx.params, ctx.parents[ncurrparent], ctx.n_parents, ctx.n_children =
		ctx.parents[ncurrparent], nil, ncurrparent - 1, currsnap
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|merging_substack|pipe to
library.merging_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent &lt; 1 then error(modulename ..
		', ‘merging_substack’: No substack has been created', 0) end
	local parent, child = ctx.parents[ncurrparent], ctx.params
	ctx.params, ctx.parents[ncurrparent], ctx.n_parents = parent, nil,
		ncurrparent - 1
	for key, val in pairs(child) do parent[key] = val end
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|flushing|pipe to
library.flushing = function (ctx)
	if ctx.n_children &lt; 1 then error(modulename ..
		', ‘flushing’: There are no substacks to flush', 0) end
	local parent, currsnap = ctx.params, ctx.n_children
	for key, val in pairs(ctx.children[currsnap]) do parent[key] = val end
	ctx.children[currsnap], ctx.n_children = nil, currsnap - 1
	return context_iterate(ctx, ctx.fnpos + 1)
end


-- Syntax:  #invoke:params|setting_by_flushing|pipe to
library.setting_by_flushing = function (ctx)
	set_strings_from_substack(ctx, ctx, 'setting_by_flushing')
	return context_iterate(ctx, ctx.fnpos + 1)
end


	--[[ Functions ]]--
	-----------------------------


-- Syntax:  #invoke:params|count
library.count = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local retval = 0
	for _ in ctx.iterfunc(ctx.params) do retval = retval + 1 end
	if ctx.subset == -1 then retval = retval - #ctx.params end
	ctx.text = retval
	return false
end


-- Syntax:  #invoke:args|concat_and_call|template name|[prepend 1]|[prepend 2]|
--            [...]|[item n]|[named item 1=value 1]|[...]|[named item n=value
--            n]|[...]
library.concat_and_call = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts, offs = ctx.pipe, ctx.fnpos
	local tname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tname == nil then error(modulename ..
		', ‘concat_and_call’: No template name was provided', 0) end
	ctx.text = ctx.frame:expandTemplate{
		title = tname,
		args = concat_params(ctx, offs + 1)
	}
	return false
end


-- Syntax:  #invoke:args|concat_and_invoke|module name|function name|[prepend
--            1]|[prepend 2]|[...]|[item n]|[named item 1=value 1]|[...]|[named
--            item n=value n]|[...]
library.concat_and_invoke = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts, offs = ctx.pipe, ctx.fnpos
	local mname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if mname == nil then error(modulename ..
		', ‘concat_and_invoke’: No module name was provided', 0) end
	local fname = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		', ‘concat_and_invoke’: No function name was provided', 0) end
	local mfunc = require('Module:' .. mname)[fname]
	if mfunc == nil then error(modulename ..
		', ‘concat_and_invoke’: The function ‘' .. fname .. '’ does not exist', 0) end
	ctx.text = mfunc(ctx.frame:newChild{
		title = 'Module:' .. mname,
		args = concat_params(ctx, offs + 2)
	})
	return false
end


-- Syntax:  #invoke:args|concat_and_magic|parser function|[prepend 1]|[prepend
--            2]|[...]|[item n]|[named item 1=value 1]|[...]|[named item n=
--            value n]|[...]
library.concat_and_magic = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts, offs = ctx.pipe, ctx.fnpos
	local magic = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if magic == nil then error(modulename ..
		', ‘concat_and_magic’: No parser function was provided', 0) end
	ctx.text = ctx.frame:callParserFunction(magic,
		concat_params(ctx, offs + 1))
	return false
end


-- Syntax:  #invoke:params|value_of|parameter name
library.value_of = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts, offs = ctx.pipe, ctx.fnpos
	if opts[offs + 1] == nil then error(modulename ..
		', ‘value_of’: No parameter name was provided', 0) end
	local val
	local key = opts[offs + 1]:match'^%s*(.-)%s*$'
	if key == '0' or key:find'^%-?[1-9]%d*$' ~= nil then
		key = tonumber(key)
		val = ctx.params[key]
		-- No worries: #ctx.params is unused when the modifier is in
		-- first position (and therefore `ctx.params` is a metatable)
		if val ~= nil and (
			ctx.subset ~= -1 or key &gt; #ctx.params or key &lt; 1
		) and (
			ctx.subset ~= 1 or (key &lt;= #ctx.params and key &gt; 0)
		) then
			ctx.text = (ctx.header or '') .. val ..
				(ctx.footer or '')
		else ctx.text = ctx.ifngiven or '' end
	else
		val = ctx.params[key]
		if ctx.subset ~= 1 and val ~= nil then ctx.text = (ctx.header
			or '') .. val .. (ctx.footer or '')
		else ctx.text = ctx.ifngiven or '' end
	end
	return false
end


-- Syntax:  #invoke:params|list
library.list = function (ctx)
	local ret, nss, kvs, pps = {}, 0, ctx.pairsep or '', ctx.itersep or ''
	flush_params(ctx, function (key, val)
		ret[nss + 1], ret[nss + 2], ret[nss + 3], ret[nss + 4], nss =
			pps, key, kvs, val, nss + 4
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 4)
	return false
end


-- Syntax:  #invoke:params|list_values
library.list_values = function (ctx)
	-- NOTE: `library.coins()` and `library.unique_coins()` rely on us
	local ret, nss, pps = {}, 0, ctx.itersep or ''
	flush_params(ctx, function (key, val)
		ret[nss + 1], ret[nss + 2], nss = pps, val, nss + 2
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|list_maybe_with_names
library.list_maybe_with_names = function (ctx)
	local ret, nss, kvs, pps = {}, 0, ctx.pairsep or '', ctx.itersep or ''
	mixed_flush_params(
		ctx,
		function (key, val)
			ret[nss + 1], ret[nss + 2], ret[nss + 3],
				ret[nss + 4], nss = pps, '', '', val, nss + 4
		end,
		function (key, val)
			ret[nss + 1], ret[nss + 2], ret[nss + 3],
				ret[nss + 4], nss = pps, key, kvs, val, nss + 4
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 4)
	return false
end


-- Syntax:  #invoke:params|for_each|wikitext
library.for_each = function (ctx)
	local ret, nss, pps, txt =
		{}, 0, ctx.itersep or '', ctx.pipe[ctx.fnpos + 1] or ''
	local skel, cnv, n_parts = parse_placeholder_string(txt)
	flush_params(ctx, function (key, val)
		for idx = 2, n_parts, 2 do
			if skel[idx] then cnv[idx] = val
			else cnv[idx] = tostring(key) end
		end
		ret[nss + 1], nss = pps, nss + 2
		ret[nss] = table.concat(cnv)
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|call_for_each|template name|[append 1]|[append 2]|
--            [...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.call_for_each = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local tname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tname == nil then error(modulename ..
		', ‘call_for_each’: No template name was provided', 0) end
	local cargs = copy_table_reduced(opts, 1, offs - 1)
	local model, ret, nss, ccs =
		{ title = tname, args = cargs }, {}, 0, ctx.itersep or ''
	flush_params(ctx, function (key, val)
		cargs[1], cargs[2], ret[nss + 1], nss = key, val, ccs, nss + 2
		ret[nss] = ctx.frame:expandTemplate(model)
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|invoke_for_each|module name|module function|[append
--            1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|
--            [named param n=value n]|[...]
library.invoke_for_each = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local mname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if mname == nil then error(modulename ..
		', ‘invoke_for_each’: No module name was provided', 0) end
	local fname = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		', ‘invoke_for_each’: No function name was provided', 0) end
	local iargs = copy_table_reduced(ctx.pipe, 1, offs)
	local model = { title = 'Module:' .. mname, args = iargs }
	local mfunc, ret, nss, ccs =
		require(model.title)[fname], {}, 0, ctx.itersep or ''
	if mfunc == nil then error(modulename ..
		', ‘invoke_for_each’: The function ‘' .. fname .. '’ does not exist', 0) end
	flush_params(ctx, function (key, val)
		iargs[1], iargs[2], ret[nss + 1], nss = key, val, ccs, nss + 2
		ret[nss] = mfunc(ctx.frame:newChild(model))
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|magic_for_each|parser function|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.magic_for_each = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local magic = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if magic == nil then error(modulename ..
		', ‘magic_for_each’: No parser function was provided', 0) end
	local ret, nss, ccs, cargs = {}, 0, ctx.itersep or '',
		copy_table_reduced(opts, 1, offs - 1)
	flush_params(ctx, function (key, val)
		cargs[1], cargs[2], ret[nss + 1], nss = key, val, ccs, nss + 2
		ret[nss] = ctx.frame:callParserFunction(magic, cargs)

	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|call_for_each_value|template name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.call_for_each_value = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local tname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tname == nil then error(modulename ..
		', ‘call_for_each_value’: No template name was provided', 0) end
	local cargs = copy_table_reduced(ctx.pipe, 1, offs)
	local model = { title = tname, args = cargs }
	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	flush_params(ctx, function (key, val)
		cargs[1], ret[nss + 1], nss = val, ccs, nss + 2
		ret[nss] = ctx.frame:expandTemplate(model)
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|invoke_for_each_value|module name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.invoke_for_each_value = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local mname = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if mname == nil then error(modulename ..
		', ‘invoke_for_each_value’: No module name was provided', 0) end
	local fname = opts[offs + 2] and opts[offs + 2]:match'^%s*(.*%S)'
	if fname == nil then error(modulename ..
		', ‘invoke_for_each_value’: No function name was provided', 0) end
	local iargs = copy_table_reduced(ctx.pipe, 1, offs + 1)
	local model = { title = 'Module:' .. mname, args = iargs }
	local mfunc, ret, nss, ccs =
		require(model.title)[fname], {}, 0, ctx.itersep or ''
	if mfunc == nil then error(modulename ..
		', ‘invoke_for_each_value’: The function ‘' .. fname .. '’ does not exist', 0) end
	flush_params(ctx, function (key, val)
		iargs[1], ret[nss + 1], nss = val, ccs, nss + 2
		ret[nss] = mfunc(ctx.frame:newChild(model))
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|magic_for_each_value|parser function|[append 1]|
--            [append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named
--            param n=value n]|[...]
library.magic_for_each_value = function (ctx)
	local opts, offs = ctx.pipe, ctx.fnpos
	local magic = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if magic == nil then error(modulename ..
		', ‘magic_for_each_value’: No parser function was provided', 0) end
	local cargs, ret, nss, ccs =
		copy_table_reduced(opts, 1, offs), {}, 0, ctx.itersep or ''
	flush_params(ctx, function (key, val)
		cargs[1], ret[nss + 1], nss = val, ccs, nss + 2
		ret[nss] = ctx.frame:callParserFunction(magic, cargs)
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|call_for_each_group|template name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.call_for_each_group = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts, offs = ctx.pipe, ctx.fnpos
	local tmp = opts[offs + 1] and opts[offs + 1]:match'^%s*(.*%S)'
	if tmp == nil then error(modulename ..
		', ‘call_for_each_group’: No template name was provided', 0) end
	local model = { title = tmp }
	local bargs, ret, nss, ccs = {}, {}, 0, ctx.itersep or ''
	for key, val in pairs(opts) do
		if type(key) ~= 'number' then bargs[key] = val
		elseif key &gt; offs then bargs[key - offs - 1] = val
		elseif key &lt; 1 then bargs[key - 1] = val end
	end
	ctx.params = make_groups(ctx.params)
	flush_params(ctx, function (gid, group)
		for key, val in pairs(bargs) do group[key] = val end
		group[0], model.args, ret[nss + 1], nss = gid, group, ccs,
			nss + 2
		ret[nss] = ctx.frame:expandTemplate(model)
	end)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


	--[[ First-position-only modifiers ]]--
	---------------------------------------


-- Syntax:  #invoke:params|new|pipe to
static_iface.new = function (child_frame)
	local ctx = context_new(child_frame, 'new')
	ctx.params = {}
	main_loop(ctx, context_iterate(ctx, 2))
	return ctx.text
end


	--[[ First-position-only functions ]]--
	---------------------------------------


-- Syntax:  #invoke:params|self
static_iface.self = function (child_frame)
	return child_frame:getParent():getTitle()
end


	--[[ Public metatable of functions ]]--
	---------------------------------------


return setmetatable({}, {
	__index = function (_, query)
		local fname = query:match'^%s*(.*%S)'
		if fname == nil then error(modulename ..
			': You must specify a function to call', 0) end
		local func = static_iface[fname]
		if func ~= nil then return func end
		func = library[fname]
		if func == nil then error(modulename ..
			': The function ‘' .. fname .. '’ does not exist', 0) end
		return function (child_frame)
			local ctx = context_new(child_frame, fname)
			ctx.params = copy_or_ref_table(ctx.oparams,
				refparams[fname])
			main_loop(ctx, func)
			return ctx.text
		end
	end
})</text>
      <sha1>ed6uj3jkl9sb18ckis1vsieht07yb7c</sha1>
    </revision>
  </page>
  <page>
    <title>Pangangghuy:Ichi Ocha</title>
    <ns>2</ns>
    <id>14635</id>
    <revision>
      <id>67239</id>
      <parentid>67102</parentid>
      <timestamp>2026-10-27T13:16:57Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <origin>67239</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="340" sha1="7t5as1bdq3zs3swxzekqic0j6c8t97e" xml:space="preserve">Halo, kaulâ Ichi Ocha angghuta komunitas Wikimadura, siap aberri' pangataowan. Salam kenal!

{{Wikilatih Wikipèḍia Madhurâ bân Ajhâr Diakritik Madura 2026}}
{{Angghuta WikiNamen}}
{{Angghuta Makrab GSF25}}
{{Kopdar Wikipèḍia Madhurâ Juli 2026}}
{{Tangtangan Bulân Asia Wikipèdia 2026}}

{{#babel:ind-N|mad-N|eng-2|tur-1|ara-1}}</text>
      <sha1>7t5as1bdq3zs3swxzekqic0j6c8t97e</sha1>
    </revision>
    <revision>
      <id>67244</id>
      <parentid>67239</parentid>
      <timestamp>2026-10-27T23:16:41Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <origin>67244</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="338" sha1="656oarhhe7593it6ufzh9rn2ow5cu5q" xml:space="preserve">Halo, kaulâ Ichi Ocha angghuta komunitas Wikimadura, siap aberri' pangataowan. Salam kenal!

{{Wikilatih Wikipèḍia Madhurâ bân Ajhâr Diakritik Madura 2026}}
{{Angghuta WikiNamen}}
{{Angghuta Makrab GSF25}}
{{Kopdar Wikipèḍia Madhurâ Juli 2026}}
{{Angghuta Bulân Asia Wikipèdia 2026}}

{{#babel:ind-N|mad-N|eng-2|tur-1|ara-1}}</text>
      <sha1>656oarhhe7593it6ufzh9rn2ow5cu5q</sha1>
    </revision>
  </page>
  <page>
    <title>Kocèng Ra'as</title>
    <ns>0</ns>
    <id>19413</id>
    <revision>
      <id>67240</id>
      <parentid>67233</parentid>
      <timestamp>2026-10-27T14:20:31Z</timestamp>
      <contributor>
        <username>Alfiyah Rizzy Afdiquni</username>
        <id>9</id>
      </contributor>
      <origin>67240</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10568" sha1="2hsh1zmf6w60wq8lcy7b9tj47hl4npb" xml:space="preserve">{{Infobox cat breed
 |name         = Raas cat
 |image        = Busok Tonduk.jpg
 |imagecaption =Solid blue adult 
 |altname      = Madura cat
 |nickname     = Busok cat (blue),&lt;br /&gt;Amethyst cat (chocolate),&lt;br /&gt;Busok-Raas, (Kucing) Buso
 |country      = {{INA}}
 |stock=population on [[Madura]] and [[Raas Island]]
 |notrecognised=true
 |landrace=landrace
 |otherstd     =
[https://sites.google.com/view/busokloversnusantara/standard-breed IBRA]&lt;br&gt;
[https://fffcat.com/upfiles/202409/05/1725523935_59o.pdf FFF] 
 }}

[[Berkas:Busok cats.jpg|jmpl|Kucing Busok Râs variasi Blue]]
[[Berkas:Blue mink Raas Busok cat.jpg|jmpl|Kucing Busok Râs variasi Lilac Mink]]
[[Berkas:Busok Hitam.png|al=Kucing Busok Black|jmpl|Kucing Busok Râs variasi Black]]
[[Berkas:Black sepia Raas cat.jpg|jmpl|Kucing Busok Râs Variasi Chocolate]]
'''Kocèng Busok Ra'as''' (èkennal kalabân '''Kocèng''' Madhurâ) aropa'aghi [[Ras Kocèng|ras]] [[kocèng|kocèng èndemik]] sè asalla ḍâri Polo Ra'as è [[Inḍonèsia]].&lt;ref name=&quot;:0&quot;&gt;{{Cite web |title=Ras Kucing Asli Indonesia |url=http://kucingkita.com/ras-kucing/ras-kucing-asli-indonesia |archive-url=https://web.archive.org/web/20160414092856/http://kucingkita.com/ras-kucing/ras-kucing-asli-indonesia |archive-date=2016-04-14 |access-date=2026-06-21 |website=KucingKita.com |language=en}}&lt;/ref&gt;&lt;ref name=&quot;:4&quot;&gt;{{Cite news |date=2014-02-19 |title=Mengenal Kucing Busok: Kucing Asli Pulau Raas |url=https://portalmadura.com/mengenal-kucing-busok-kucing-asli-pulau-raas/6682/ |access-date=2026-06-21 |work=PortalMadura.com |language=en-US}}&lt;/ref&gt;&lt;ref name=&quot;:1&quot;&gt;{{Cite web |title=Daya Tarik Warna Buso pada Kucing Madura |url=http://www.meongers.com/1/post/2013/10/daya-tarik-warna-buso-pada-kucing-madura.html |access-date=2026-06-21 |website=Meongers |language=en |archive-date=2014-05-16 |archive-url=https://web.archive.org/web/20140516101319/http://www.meongers.com/1/post/2013/10/daya-tarik-warna-buso-pada-kucing-madura.html |url-status=dead }}&lt;/ref&gt;&lt;ref name=&quot;:2&quot;&gt;{{Cite web |last=Admin |title=MEMBURU KUCING MADURA! |url=http://www.lppm.ipb.ac.id/index.php?option=com_content&amp;view=article&amp;id=541:memburu-kucing-madura-&amp;catid=38:warta-iptek&amp;Itemid=50 |archive-url=https://web.archive.org/web/20160412063210/http://www.lppm.ipb.ac.id/index.php?option=com_content&amp;view=article&amp;id=541:memburu-kucing-madura-&amp;catid=38:warta-iptek&amp;Itemid=50 |archive-date=2016-04-12 |access-date=2026-06-21 |website=www.lppm.ipb.ac.id |language=en-gb}}&lt;/ref&gt; Busok Ra'as aropa'aghi ras kocèng murni taḍâ' camporan gèn ḍâri ras kocèng laènna.&lt;ref name=&quot;:1&quot; /&gt;&lt;ref name=&quot;:2&quot; /&gt; Kocèng rèya tamaso' kocèng sè rang-rang bâḍâ bân anḍi' variasi gènètika sè tèngghi. per taon 2016, ra-kèra Kocèng Busok Ra'as kalabân gen sè sokkla coma korang ḍâri 100 bigghi'.&lt;ref name=&quot;:3&quot;&gt;{{Cite web |title=BREEDS ORIGINATING FROM SOUTH-EAST ASIA |url=http://messybeast.com/southeastasian-breeds.htm |access-date=2026-06-21 |website=messybeast.com}}&lt;/ref&gt; Kocèng Busok Ra'as satèya bâḍâ 4 variasi bârna iyâ arèya bhiru/bu-abu, ''black''/celleng, ''chocolate''/sokklat, bân ''lilac'' kalabân ciri khassa bunto' sè panḍâ' bân bilu'. Kocèng Busok satèya anḍi' ''wadah'' sè anyama IBRA (Indonesian Busok Ra'as Asosiation) sè èpaddhek bi' I Putu Aditya Perdana, Hany Kolopaking, Dionisius Suharmin, bân Dr. Vimala Dewi Lukito.&lt;ref name=&quot;:3&quot; /&gt;

Bâḍâna kocèng rèya coma kadhâddhiyân è Polo Ra'as. Kocèng Busok Ra'as cè' èkaèmanè pas èjâgâ bi' rèng-orèng è Polo Ra'as,&lt;ref name=&quot;:0&quot; /&gt;&lt;ref name=&quot;:1&quot; /&gt; saèngghâ alarang ras kocèng rèya ngallè ka lowar polo.&lt;ref name=&quot;:5&quot;&gt;{{Cite web |title=#nationalcatday, Perjuangkan Kucing Busok Madura |url=https://surabaya.tribunnews.com/2014/10/30/nationalcatday-perjuangkan-kucing-busok-madura |access-date=2026-06-21 |website=Surya.co.id |language=id-ID}}&lt;/ref&gt; Biyasana coma kocèng Busok Ra'as sè la è [[Pajhubenga kèbân|kabhiri]] sè ollè è ghibâ ngallè ka lowar polo ma'lè kamurniyanna Busok Ra'as teptep kajâgâ. Kalahèranna ana'na kocèng Busok Ra'as kalabân bârna bhiru pastè è tos-nantos bân rèng-orèng Polo Ra'as. [[Buḍu’ân kocèng|Buḍu'ân kocèng]] jârèyâ ḍâgghi' bhâkal èberri' ka rèng-orèng tartanto ghâbây hadiyâ, akadhiyâ sè senneng ka kocèng.&lt;ref name=&quot;:0&quot; /&gt;&lt;ref name=&quot;:1&quot; /&gt;

== Sajharâ ==
Busok Ra'as aropa'aghi kocèng sè awwâl molana ta' èkataowè asal-osolla. Coma ra-kèra kocèng rèya bâḍâ sacara alami.&lt;ref name=&quot;:1&quot; /&gt; Mètorot orèng Polo Ra'as anyata'aghi kocèng Busok Ra'as acèpta ḍâri hasèl kabinanna kocèng Pitua (atanḍu') kalabân kocèng ḍomèstik polo Ra'as. Salaèn ḍâri jârèya kocèng busok Ra'as èparcajâ jhâ' asalla ḍâri ras Asia karana ropa bunto'na sè bilu' è bâgiyân konco'na.&lt;ref name=&quot;:1&quot; /&gt;&lt;ref name=&quot;:2&quot; /&gt;

Bânnya' rèng-orèng sè terro tao onèng kocèng busok akadhi kalompo' sè senneng ka kocèng è Inḍonèsia. Kalompo' kocèng jârèya terro kabâḍâ'ân kocèng Busok pagghun terros bâḍâ bân kocèng jârèya bisa èyakowè è dhunnya Internasional. Sabâgiyân kocèng Busok Ra'as perna kèya èghibâ ka lowar Polo Ra'as ka'angghuy pangembangan, saènggha pan-bârampan kocèng Busok Ra'as bisa è emmowè è [[Bhâli]], [[Daerah Khusus Ibukota Jakarta|Jâkarta]], [[Songennep]],  [[Kottha Banḍung|Bandung]], Bogor,&lt;ref&gt;{{Cite web |last=Berlian |first=Daurina Lestari, Isra |date=2017-12-05 |title=Sumenep Gelar 39 Agenda Wisata di 2018, Catat Tanggalnya |url=https://www.viva.co.id/gaya-hidup/travel/984573-sumenep-gelar-39-agenda-wisata-di-2018-catat-tanggalnya |access-date=2026-06-23 |website=www.viva.co.id |language=id}}&lt;/ref&gt; bân è [[Kottha Semarang|Semarang]].&lt;ref&gt;{{Cite web |title=Ini Dia Kucing Busok Khas Pulau Raas Indonesia, Mata Tajam dan Berwibawa |url=https://jateng.tribunnews.com/2017/08/22/ini-dia-kucing-busok-khas-pulau-raas-indonesia-mata-tajam-dan-berwibawa |access-date=2026-06-23 |website=Tribunjateng.com |language=id-ID}}&lt;/ref&gt;

== Sèpat ==
Busok Ra'as anḍi' karakteristik fisik sè para' paḍâ'â bân macan tol-tol bân kocèng hutan.&lt;ref name=&quot;:0&quot; /&gt;&lt;ref name=&quot;:4&quot; /&gt;&lt;ref name=&quot;:1&quot; /&gt; Busok Ra'as aropa'aghi kocèng sè tampilanna anggun&lt;ref name=&quot;:1&quot; /&gt; bân okoranna seḍḍheng kalabân okoran sè lebbi rajâ ḍâri okoranna ras kocèng biyasana.&lt;ref name=&quot;:0&quot; /&gt; Mowa kocèng rèya abhângon masaghi tello' bân sakonè' masaghi kalabân cangkèm sè lancèp sakonè'.&lt;ref name=&quot;:4&quot; /&gt; Kopèngnga manjheng ka aḍâ',&lt;ref&gt;{{Cite web |last=Dehandoko |first=SYAHRUL SYAIFUDIN ANSYARI |date=2015-05-29 |title=Raas, Kucing Para Bangsawan dan Ulama Madura |url=https://www.viva.co.id/berita/nasional/631523-raas-kucing-para-bangsawan-dan-ulama-madura |access-date=2026-08-03 |website=www.viva.co.id |language=id}}&lt;/ref&gt; lanjhâng bân akonco'.&lt;ref name=&quot;:1&quot; /&gt; Kocèng rèya anḍi' bunto' sè lanjhâng kalabân sabâgiyân bâgiyanna sè bilu'.&lt;ref&gt;{{Cite news |date=2015-08-28 |title=Raas, Kucing Asli Indonesia Dari Madura - Meowmagz |url=http://meowmagz.com/2015/08/raas-kucing-asli-indonesia-dari-madura/ |access-date=2026-06-23 |work=Meowmagz |language=en-US |archive-date=2016-06-29 |archive-url=https://web.archive.org/web/20160629143743/http://meowmagz.com/2015/08/raas-kucing-asli-indonesia-dari-madura/ |url-status=dead }}&lt;/ref&gt; Busok Ra'as anḍi' bârna mata sè bhiru towa bân biyasana abârna bhiru mon kocèng sè abârna soklat towa&lt;ref name=&quot;:2&quot; /&gt; kalabân bhângon oval bân matana ta' cè' lèbârrâ.&lt;ref name=&quot;:4&quot; /&gt;

Busok Ra'as anḍi' bulu sè pènḍâ' tor alos bân lembu'.&lt;ref name=&quot;:4&quot; /&gt; Busok Ra'as hadir ḍâlem pola solid,&lt;ref name=&quot;:3&quot; /&gt; ḍuwâ' bârna,&lt;ref name=&quot;:6&quot;&gt;{{Cite web |date=2016-08-17 |title=Kucing Raas, Kucing Busok dan Kucing Kecubung |url=http://kucingraas.co.id/kucing-raas-kucing-busok-dan-kucing-kecubung/ |archive-url=https://web.archive.org/web/20161030161239/http://kucingraas.co.id/kucing-raas-kucing-busok-dan-kucing-kecubung/ |archive-date=2016-10-30 |access-date=2026-08-02 |website=kucingraas.co.id |language=en-US}}&lt;/ref&gt; bân tètè' bârna,&lt;ref name=&quot;:0&quot; /&gt;&lt;ref name=&quot;:4&quot; /&gt;&lt;ref name=&quot;:1&quot; /&gt; kalabân bârna bhiru (bu-abu) bân kaju manès (sokklat towa).&lt;ref name=&quot;:2&quot; /&gt; Bârna blue bisa hadir ḍâlem pola solid otabâ ḍuwâ' bârna kalabân bulu bârna blue sè bâḍâ è sabâgiyân bhâdhânna bân bârna potè sè bâḍâ è bâgiyân ḍâḍâ bân tabu'na kalabân bâtes sè ta' jellas.&lt;ref name=&quot;:3&quot; /&gt; Dhinèng bârna kaju manès bisa hadir ḍâlem pola solid otabâ tètè' bârna.&lt;ref name=&quot;:3&quot; /&gt; Kocèng bârna blue èkennal kalabân nyama '''kocèng busok''', dhinèng sè bârna kaju manès èsebbhut kalabân nyama '''kocèng kacobhung'''.&lt;ref name=&quot;:6&quot; /&gt; Kocèng kacobhung panèka jenis sè palèng rangrang po'dul bân maso' bârna resesif.&lt;ref name=&quot;:1&quot; /&gt;&lt;ref name=&quot;:2&quot; /&gt; Tapè seiring perkembangana bâkto po'dul variasi anyar èngghi bârna '''Black''' bân '''Lilac'''.

== Kepribadian ==
Kocèng Busok Ra'as è alam liarra iyâ arèya kocèng sè tako' kalabân manossa, saèngghâ kocèng jârèya sè malarat ka'angghuy adaptasi.&lt;ref name=&quot;:5&quot; /&gt; Kocèng Busok Ra'as anḍi' karakter sè lebbi ajhir kalowarga sa'amponna bâḍâna penangkaran bân pemurnian sampè' ḍâpa' generasi ka-4 (F4). Kocèng rèya cè' ngarghâna ḍâ' ka sè arabât bân korang bisa narèma kahadirana orèng laèn salaèn sè arabât. Tapè, mon la terbiasa ḍâ' lingkunganna, kocèng rèya cè' ghâmpangnga aadaptasi tor cè'  akancana.&lt;ref&gt;{{Cite web |title=hewanee.com |url=https://hewanee.com/kucing-busok/ |access-date=2026-08-02 |website=hewanee.com |archive-date=2023-09-29 |archive-url=https://web.archive.org/web/20230929090708/https://hewanee.com/kucing-busok/ |url-status=dead }}&lt;/ref&gt; Karaktera sè neng-enneng, lebbi ngoca' jhâ' kocèng rèya toḍusân bân ngastètè, tapè seiring bâkto, kocèng rèya bhâkal dhâddhi kanca. Bânnya’ sè ahèrra dâddhi kocèng ma-roma sè cè' manjâna.

Bâkto sapih buḍu'na ètanḍhâi kalabân cè' jellassa, bân è omor 3 bulân bâkal èkalako sampe' buḍu'na bisa anḍi' ana' maksimal 1 taon 3 kalè. Tapè, ḍâlem situasi tartanto, lebbi bhâghus èpakabin bilâ kondisi bâdhânna la abâli polè, tampa' anḍi' dhâghing bân lempo. Tojjhuwânna marè mon nganḍung polè buḍu'na' bân korbina ḍâlem kondisi prima.

== Sombher ==
&lt;references /&gt;

[[Bhângsa:Kèbân]]
[[Bhângsa:Ras kocèng langka]]
[[Bhângsa:Ras kocèng sè asalla ḍâri inḍonèsia]]
[[Bhângsa:Ras kocèng domestik]]</text>
      <sha1>2hsh1zmf6w60wq8lcy7b9tj47hl4npb</sha1>
    </revision>
  </page>
  <page>
    <title>Wikipèḍia:Angghuta Bulân Asia Wikipèḍia 2026</title>
    <ns>4</ns>
    <id>19918</id>
    <revision>
      <id>67234</id>
      <timestamp>2026-10-27T12:51:37Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <comment>←Membuat halaman berisi 'Angghuta Bulân Asia Wikipèḍia 2026'</comment>
      <origin>67234</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="38" sha1="5sjxomljppy0a8vj3l6dbtxx4a5fjhy" xml:space="preserve">Angghuta Bulân Asia Wikipèḍia 2026</text>
      <sha1>5sjxomljppy0a8vj3l6dbtxx4a5fjhy</sha1>
    </revision>
    <revision>
      <id>67237</id>
      <parentid>67234</parentid>
      <timestamp>2026-10-27T13:06:20Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <origin>67237</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="66" sha1="dxq60t138ec57zbukd4x5asqleygv6e" xml:space="preserve">Pangangguy panèka dhâddhi Angghuta Bulân Asia Wikipèḍia 2026</text>
      <sha1>dxq60t138ec57zbukd4x5asqleygv6e</sha1>
    </revision>
  </page>
  <page>
    <title>Angghuta Bulân Asia Wikipèḍia 2026</title>
    <ns>0</ns>
    <id>19919</id>
    <revision>
      <id>67235</id>
      <timestamp>2026-10-27T12:53:24Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <comment>←Membuat halaman berisi 'Angghuta Bulân Asia Wikipèḍia 2026'</comment>
      <origin>67235</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="38" sha1="5sjxomljppy0a8vj3l6dbtxx4a5fjhy" xml:space="preserve">Angghuta Bulân Asia Wikipèḍia 2026</text>
      <sha1>5sjxomljppy0a8vj3l6dbtxx4a5fjhy</sha1>
    </revision>
  </page>
  <page>
    <title>Cèṭa'an:Angghuta Bulân Asia Wikipèdia 2026</title>
    <ns>10</ns>
    <id>19920</id>
    <revision>
      <id>67236</id>
      <timestamp>2026-10-27T12:54:22Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <comment>←Membuat halaman berisi '{{userbox | border-c      = #bbb | id            = [[Bhengkek: Wikipedia Asian Month Logo v2 ms.svg|80px]] | id-c          = #fff | id-s          = 12 | info          = Pangangghuy nèka dhâddhi '''[[Angghuta Bulân Asia Wikipèḍia 2026]]'''. | info-c        = #f6f6f6 | info-fc       = #000 }} &lt;includeonly&gt;[[Bhângsa:Angghuta Bulân Asia Wikipèḍia 2026|{{PAGENAME}}]]&lt;/includeonly&gt;&lt;noinclude&gt; Bhângsa:Templat pengguna|Angghuta Bulân Asia Wikipèḍia 2026...'</comment>
      <origin>67236</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="505" sha1="mxnmzj1bj2rd6afvxyjswjg0i3smtl7" xml:space="preserve">{{userbox
| border-c      = #bbb
| id            = [[Bhengkek: Wikipedia Asian Month Logo v2 ms.svg|80px]]
| id-c          = #fff
| id-s          = 12
| info          = Pangangghuy nèka dhâddhi '''[[Angghuta Bulân Asia Wikipèḍia 2026]]'''.
| info-c        = #f6f6f6
| info-fc       = #000
}}
&lt;includeonly&gt;[[Bhângsa:Angghuta Bulân Asia Wikipèḍia 2026|{{PAGENAME}}]]&lt;/includeonly&gt;&lt;noinclude&gt;
[[Bhângsa:Templat pengguna|Angghuta Bulân Asia Wikipèḍia 2026]]
[[Bhângsa:tantangan]]
&lt;/noinclude&gt;</text>
      <sha1>mxnmzj1bj2rd6afvxyjswjg0i3smtl7</sha1>
    </revision>
    <revision>
      <id>67242</id>
      <parentid>67236</parentid>
      <timestamp>2026-10-27T23:15:24Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <origin>67242</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="254" sha1="6ky59gagedaospqw2xqi6ys6ghvljgc" xml:space="preserve">{{Userbox
| border-c = #006699
| id-c = #ffffff
| id = [[File:Wikipedia Asian Month Logo v2 ms.svg|80px]]
| info-c = #e6f2f8
| info = Pangangghuy nèka dhaddhi '''Angghuta Bulân Asia Wikipèdia 2026'''}}
[[Category:Angghuta Bulân Asia Wikipèdia 2026]]</text>
      <sha1>6ky59gagedaospqw2xqi6ys6ghvljgc</sha1>
    </revision>
  </page>
  <page>
    <title>Cèṭa'an:Tangtangan Bulân Asia Wikipèdia 2026</title>
    <ns>10</ns>
    <id>19921</id>
    <revision>
      <id>67238</id>
      <timestamp>2026-10-27T13:13:47Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <comment>←Membuat halaman berisi '{{Userbox | border-c = #006699 | id-c = #ffffff | id = [[File:Wikipedia Asian Month Logo v2 ms.svg|80px]] | info-c = #e6f2f8 | info = Pangangghuy nèka nuro' '''Tangtangan Bulân Asia Wikipèdia 2026'''}} [[Category:Tangtangan Bulân Asia Wikipèdia 2026]]'</comment>
      <origin>67238</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="256" sha1="4qin8u93byxahyln8ftvg6gve011piw" xml:space="preserve">{{Userbox
| border-c = #006699
| id-c = #ffffff
| id = [[File:Wikipedia Asian Month Logo v2 ms.svg|80px]]
| info-c = #e6f2f8
| info = Pangangghuy nèka nuro' '''Tangtangan Bulân Asia Wikipèdia 2026'''}}
[[Category:Tangtangan Bulân Asia Wikipèdia 2026]]</text>
      <sha1>4qin8u93byxahyln8ftvg6gve011piw</sha1>
    </revision>
  </page>
  <page>
    <title>Bhângsa:Angghuta Bulân Asia Wikipèdia 2026</title>
    <ns>14</ns>
    <id>19922</id>
    <revision>
      <id>67243</id>
      <timestamp>2026-10-27T23:15:42Z</timestamp>
      <contributor>
        <username>Ichi Ocha</username>
        <id>3826</id>
      </contributor>
      <comment>←Membuat halaman berisi 'Angghuta Bulân Asia Wikipèdia 2026'</comment>
      <origin>67243</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36" sha1="nukenyup1cl17v44usomlk9brbuwlk2" xml:space="preserve">Angghuta Bulân Asia Wikipèdia 2026</text>
      <sha1>nukenyup1cl17v44usomlk9brbuwlk2</sha1>
    </revision>
  </page>
  <page>
    <title>Bal Budi</title>
    <ns>0</ns>
    <id>19924</id>
    <revision>
      <id>67245</id>
      <timestamp>2026-10-28T06:28:48Z</timestamp>
      <contributor>
        <username>Royeksdinata</username>
        <id>5862</id>
      </contributor>
      <comment>Bal buḍi</comment>
      <origin>67245</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2512" sha1="3e6fk410n9tm4zeuj3uthc2oa5l4m2l" xml:space="preserve">Bal buḍi aropaagghi olahraga kona sè kalonta neng è Sumenep otamana dâri bâgiyân Lènteng, Rubâru sampè' Bluto. Olahraga arèya aghunaaghi bal otabâ tembhung kènè' sè èdimma bânynya'na sanga' orèng. Dâri sanga' orèng arèya, tello' orèng sè ngambâ' bal èadâ' èkoca' Komandu, sèttong orèng èpaddhu kangan èkoca' Panyumpet, duwâ' orèng è pèngghir kangan bân kacèr ekoca' Sayap bân tello' orèng karèna ekoca' Kaptèn.

[[Bal budi|Bal buḍi]] jhughân aropaaghi olaharaga sè aghândhu' atoran maèn sè amacem: sèttong, sabbhân orèng sè amaèn bilâ ngucol bal otabâ tembhung ta' ollè toron dâri kennengan sè enyamaè Eppak bân ènyataaghi maso' dâddhi skor nalèka bal otabâ tembhung kasebbhut tak kalowar dâri kotakan masaghi lapangan. Ḍuwâ', orèng sè amain aropaaghi ḍuwâ'  kompolan dâri marghâsarè sè bidhâ. Akadhi conto, kompolan sè ngucol dâri dhisa Lèmbung Bârâ' dâjâ songay sè kalonta kalabân sebbhudhân PBT PÈNA HITAM, seddehengan sè ngambâ' aropaaghi kompolan bal budi ḍâri dhisa Lèmbung Bâra' bâgiyân pajhuko'an sè kalonta kalabân sebbhudhân PBT KUḌA TERBANG. Sè nomer tello', sala sèttong dâri komplolan sè ènyamae PBT kashebbhut ènyataaghi menang, nalèka skor sala sèttong PBT kashebbhut lebbi bânnya' ḍâri PBT sè dâdhi mosona.

Skor Bal budi ètantowaghi ḍâri pan sapoapan bâgiyân. Sèttong, orèng sè ngucol amulaè ḍâri teppakan budi. Saellana maso', maka skor otabaâ poinna dâddhi sèttong  pas lajhu teppakan adâ' sampè' lèma' poin. Saellana maso' lèma' poin, maka bal otabâ tembhung kashebbhut ètandhu' bân nalèkana maso', maka ènyataaghi poin sè èsebbhut kalabân sabindel. Bâgiyân sè nomer ḍuwâ' aropaaghi kennengan sè bhâkal èkennengi amaèn. Sabâgiyân kompolan otabâ PBT torkaḍhâng dâadhi sè nangghâ' otabâ tuan ruma, seddhengan PBT mosona, nompo ḍa' ka tuan ruma kasebbhut saengghâna kalonta kalabân tompowan.

Bal budi ta' coma ebâḍâaghi kaanghuy amaèn biasa. Torkaḍhâng bilâ mosèm nèmor, Bal budi èpadhâddhi lomba kaangghuy bhân sabbân dhisa sè bâḍâ è Sumenep. Akadhiye lomba sè èbâḍâaghi è dhisa Lènteng Bârâ' sè kalonta kalabân Event Joko Mellèng. Anapon kompolan otabâ PBT sè menang bhâkal ngaollè pan saponapan bhârang, molae dari mobil sampè motor. Sè tojjhuwenna taḍâ, laèn kaangghuy nambâ kowata talè satarètanan bân kakompaghân maghârsarè Sumenep otamana lèbet bâḍâna Bal budi.</text>
      <sha1>3e6fk410n9tm4zeuj3uthc2oa5l4m2l</sha1>
    </revision>
  </page>
</mediawiki>