モジュール:Bufferのソースを表示

●モジュール ●ノート ●閲覧 ●ソースを閲覧 ●履歴表示ツール操作 ●閲覧 ●ソースを閲覧 ●履歴表示全般 ●リンク元 ●関連ページの更新状況 ●ファイルをアップロード ●特別ページ ●ページ情報 ●短縮URLを取得する ●QRコードをダウンロード ●ウィキデータ項目 ← モジュール:Buffer あなたには﹁このページの編集﹂を行う権限がありません。理由は以下の通りです: このページは保護されています。 ●Wikipedia:保護の方針に基づき全保護されているため、保護期間中管理者以外の方は編集できません。 ●保護の経緯およびその期間はこのページの保護記録で確認できます。 ●このページのノートで保護について議論が行われていることがありますので、ご参照願います。
このページのソースの閲覧やコピーができます。
--[[=============================
This Module was written by Alexander Zhikun He, also known as, User:Codehydro on the English Wikipedia

All methods were developed independently and any resemblance to other string buffer libraries would be coincidental.
Furthermore, many methods will not work when compiled by standard Lua libraries as they depend on behaviors unique to
the MediaMiki Scribunto mod, which, for example, has a getmetatable() method that always returns nil on non-tables.
https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual

Source code comments may be thin at some points because they are intended to be supplemented by the documentation page:
https://en.wikipedia.org/wiki/Module:Buffer/doc

Licensed under Creative Commons Attribution-ShareAlike 3.0 Unported License
https://en.wikipedia.org/wiki/Wikipedia:Text_of_Creative_Commons_Attribution-ShareAlike_3.0_Unported_License

https://en.wikipedia.org/wiki/Module:Buffer
https://en.wikipedia.org/wiki/User:Codehydro
=============================--]]
local function Valid(<span class="ltr">v</span>)--type validation
 if v and v~=true then--reject nil/boolean; faster than 2 type() comparisons
  local str = tostring(<span class="ltr">v</span>)--functions not filtered since unlikely passed by accident (Scribunto does not have userdata/thread types)
  if str~=v and str=='table' then return rawget(v, 1) and table.concat(<span class="ltr">v</span>) end--tostring(string-type) returns same ref; same refs compare faster than type()
  if str~='' then return str end--numbers are coerced to string per table.concat op; appending in string form saves ops on repeat concat
 end
end
local noOp, MBpairs = function()end do local iMap, vMap, oMap, pIter, pOther, pFast, Next--Map
 local function init()--init = noOp after first run
  function Next(<span class="ltr">t</span>) return next, t end--slightly faster to do this than to use select()
  function pIter(t, k) k = (iMap[<span class="ltr">t</span>] or MBpairs(t, true) and iMap[<span class="ltr">t</span>])[not k and 1 or vMap[<span class="ltr">t</span>][<span class="ltr">k</span>]] return k, t[<span class="ltr">k</span>] end--don't use rawget; accepting unmapped tables does not measurably affect performance.
  function pOther(t, k) k = (oMap[<span class="ltr">t</span>] or MBpairs(t, true) and oMap[<span class="ltr">t</span>])[nil==k and 1 or vMap[<span class="ltr">t</span>][<span class="ltr">k</span>]] return k, t[<span class="ltr">k</span>] end--comparison to nil because false is a valid key
  function pFast(t, k) k = not k and 1 or k < (vMap[<span class="ltr">t</span>] or #t) and k + 1 or nil return k, t[<span class="ltr">k</span>] end--mapless iterator; almost as fast as native ipairs; slight performance penalty when length not cached
          --k and k < (vMap[<span class="ltr">t</span>] or #t) and k + 1 or not k and 1 or nil return k, t[<span class="ltr">k</span>] end--mapless iterator; almost as fast as native ipairs; slight performance penalty when length not cached
  local mk = {__mode = 'k'}--use mode 'k'; found that mode 'kv' sometimes garbage collects maps mid-loop (may not error because iterators auto re-map, but that's expensive)
  init, iMap, vMap, oMap = noOp, setmetatable({}, mk), setmetatable({}, mk), setmetatable({}, mk)--iMap is numeric keys, oMap is non-numeric keys, and vMap points to next key
 end
 function MBpairs(t, ...)--pairs always iterates in order
  local iter, ex = ...
  iter = iter==init()--nil
  if iter and not oMap[<span class="ltr">t</span>] and ex==nil and rawget(t, 1)~=nil and next(t, #t)==nil then--while possible to miss keys, more thorough check would negate the benefit of pFast
   vMap[<span class="ltr">t</span>] = #t return pFast, t, nil
  elseif ... or not vMap[<span class="ltr">t</span>] or select('#', ...)~=1 then
   local ti, tn, to, n = {}, {}, {}, #t--reduces table lookups
   iMap[<span class="ltr">t</span>], vMap[<span class="ltr">t</span>], oMap[<span class="ltr">t</span>] = ti, tn, to
   for k = 1, n do ti[<span class="ltr">k</span>], tn[<span class="ltr">k</span>] = k, k + 1 end--stage one avoids number type checking op in stage two for most numeric keys
   for k in (ex or Next)(<span class="ltr">t</span>) do
    if not tn[<span class="ltr">k</span>] then table.insert(tonumber(<span class="ltr">k</span>)~=k and to or ti, k) end
   end
   if #ti~=n then
    table.sort(<span class="ltr">ti</span>)
    for k = 1, #ti do tn[ti[<span class="ltr">k</span>]] = k + 1 end--somewhat wasteful, but trying to avoid overwriting can be even more expensive
   end
   for k = 1, #to do tn[to[<span class="ltr">k</span>]] = k + 1 end
  end
  return iter and pIter or oMap[<span class="ltr">t</span>] and pOther or noOp, t--noOp for mapless
 end
end
local parent, rawkey, spec do--new scope for variables not reused outside (reduces number of var names that need to checked outside of scope)
 local mkv = {__mode='kv', __call=function(t,k,v)t[<span class="ltr">k</span>]=v return k end}--shared meta for Buffer parent property, raw mode, and specialized functions
 parent, rawkey, spec = setmetatable({}, mkv), setmetatable({}, mkv), setmetatable({}, mkv)--shared meta less memory
end

local MB, MBi, MBmix, buffHTML, gfuncs, noCache, Element do--minimize number of locals per scope to reduce time spent sifting through irrelevant variable names
 local _stream do local stream--keep stream near top of scope
  local function init(<span class="ltr">f</span>)--init = noOp after first run
   local function each(self, ...)
    for k = 1, select('#', ...) do
     k = Valid(select(k, ...))--slightly faster than table.insert(self, (Valid(select(k, ...))))
     if k then table.insert(self, k) end
    end
    return self
   end
   init, stream, _stream = noOp, {
    __call = function(t, v) v = v and Valid(<span class="ltr">v</span>) return v and table.insert(t, v) or t end,--last_concat cleared before entering stream mode
    __index = function(t, i) return i=='each' and each or MB.__index(t, i) and setmetatable(t, MB)[<span class="ltr">i</span>] end,--no table look up minimizes resources to retrieve the only stream function
    __tostring = function(<span class="ltr">t</span>) return setmetatable(t, MB)() end
   } for k, v in next, MB do stream[<span class="ltr">k</span>] = stream[<span class="ltr">k</span>] or v end
   setmetatable(stream, getmetatable(<span class="ltr">MB</span>))
  end
  function _stream(self, ...) self.last_concat = init() return setmetatable(self, stream):each(...) end
 end
 local function isMBfunc(Buffer, s, ...)--helper for :getParent()-like methods (including getBuffer which does not return a parent)
  return s and (select('#', ...)==0 and--eventually should figure out to make this work for :getHTML which is very similar
    (not rawkey[<span class="ltr">s</span>] and tostring(<span class="ltr">s</span>):match'^_.*' and MB.__index(Buffer, s) and MB.__index(Buffer, s)(Buffer) or MBmix(Buffer, s))--unprefixed function names append as a string
    or assert(MB.__index(Buffer, s), ('" %s " does not match any available Module:Buffer function'):format(<span class="ltr">s</span>))(Buffer, ...)--getParent is a one-way trip so one-time assert not expensive
   ) or Buffer
 end
 local function MBselect(n, ...)--helper for :_out and :_str
  local n, seps = n - 1, {select(2, ...)}
  if type(seps[<span class="ltr">n</span>])=='table' then 
   if buffHTML and rawget(seps[<span class="ltr">n</span>], buffHTML) then return ... end
   setmetatable(seps, {__index = setmetatable(seps[<span class="ltr">n</span>], {__index = function(<span class="ltr">t</span>) return rawget(t, 1) end})})[<span class="ltr">n</span>] = nil
  end
  return ..., seps
 end
 local _inHTML do local lastBuffer, lastHTML
  local function init(...)--init replaced and new version called on return
   local create, mwFunc = mw.html.create do
    local mwHTMLmeta = getmetatable(create())
    buffHTML, mwFunc, _inHTML = setmetatable(mw.clone(mwHTMLmeta), getmetatable(<span class="ltr">MB</span>)), mwHTMLmeta.__index--buffHTML declared near top of module; remove _inHTML from outer scope
    function init(nodes, ...)
     local name, args, tag = select(... and type(...)=='table' and 1 or 2, nil, ...)
     tag = create(Valid(name), args)
     if nodes then table.insert(nodes, tag.parent and tag or rawset(tag, 'parent', parent[nodes])) end
     if args then
      local a, b = args.selfClosing, args.parent
      args.selfClosing, args.parent = nil
      if next(args) then Element._add(parent(tag.nodes, tag), args) end
      args.selfClosing, args.parent = a, b--in case args is reused
     end
     return tag
    end
    for k, v in next, {[<span class="ltr">mw</span>] = mwHTMLmeta,
     __call = function(h, v) return MBmix(spec[h.nodes] and h.nodes or spec(setmetatable(parent(h.nodes, h), MB), Element), v) end,
     __concat = false,--false means take from MB
     __eq = false
    } do buffHTML[<span class="ltr">k</span>] = v or MB[<span class="ltr">k</span>] end
   end
   local nonSelf, BHi = {tag=true,done=true,allDone=true}, buffHTML.__index do local g
    g = {__index = function(t, i)
     if gfuncs and gfuncs[<span class="ltr">i</span>] then g.__index, gfuncs = gfuncs return g.__index[<span class="ltr">i</span>] end
    end}
    setmetatable(nonSelf, g)
    setmetatable(BHi, g)
   end
   for k in next, nonSelf do--any HTML objects returned by these funcs will be granted Module:Buffer enhancements
    local func = mwFunc[<span class="ltr">k</span>]
    BHi[<span class="ltr">k</span>] = function(t, ...) local HTML = func(t, ...) return parent[HTML] and HTML or setmetatable(parent(HTML, t), buffHTML) end
   end
   do local function joinNode(HTML, sep)
     local nodes, join = HTML.nodes
     if noCache and rawkey[sep] or Valid(sep) then join, HTML.nodes = tostring(rawset(HTML, 'nodes', {MB.__call(nodes, sep)})), nodes end
     return join or tostring(HTML)
    end
    for k, v in next, {
     getParent = function(HTML, ...) lastHTML = HTML return MBi.getParent(HTML:allDone(), ...) end,--return to Buffer that created the HTML tree
     getBuffer = function(HTML, ...) lastHTML = HTML return isMBfunc(lastBuffer, ...) end,--return to last used
     killParent = function(HTML, ...) MBi.killParent(HTML:allDone(), ...) return HTML end,
     _out = function(HTML, ...)
      if ...==0 then MBi._out(HTML.nodes, ...) return HTML end
      lastHTML, HTML = HTML, HTML:allDone()
      local n, ops, seps = select('#', ...)
      if n > 1 then
       local ops, seps = MBselect(n, ...)
       return parent[HTML]:_in(joinNode(HTML, rawget(seps, 0))):_out(ops, rawset(seps, buffHTML, true))
      end
      return parent[HTML]:_(joinNode(HTML, ...))
     end,
     _str = function(HTML, ...)--does not set lastHTML
      if ...==0 then return joinNode(HTML, select(2, ...)) end--passing 0 strings without calling allDone()
      local HTML, n = HTML:allDone(), select('#', ...)
      if n > 1 then
       local ops, seps = MBselect(n, ...)
       return parent[HTML]:_in(joinNode(HTML, rawget(seps, 1))):_str(ops, rawset(seps, buffHTML, true))
      end
      return joinNode(HTML, ...)
     end,
     _parent = function(HTML, ...) table.insert(HTML.nodes, parent[HTML:allDone()]:_str(...)) return HTML end
    } do BHi[<span class="ltr">k</span>] = v end
   end
   do local htmlArg, skip, outFuncs = {parent=true,selfClosing=true,tagName=true}, {}
    do local out local function func(nodes, ...) return out(parent[nodes], ...) end
     outFuncs = setmetatable({
      tag = function(nodes, ...) return parent(setmetatable(init(nodes, ...), buffHTML), parent[nodes]) end,
      done = function(b, ops)
       b = parent[<span class="ltr">b</span>] 
       while b.parent and ops~=0 do b, ops = b.parent, ops and ops - 1 or 0 end
       return b
      end
     }, {__index = function(nodes, i)
      if rawget(BHi, i) then out = BHi[<span class="ltr">i</span>] return func end--rawget to exclude globals
     end})
    end
    Element = {
     _add = function(nodes, t)
      for k, v in MBpairs(<span class="ltr">t</span>), t, skip[<span class="ltr">t</span>] do (v~=true and MBmix or noOp)(nodes, v) end
      local HTML = parent[nodes] for k, v in MBpairs(t, false) do
       if htmlArg[<span class="ltr">k</span>] then HTML[<span class="ltr">k</span>] = v
       elseif v and v~=true then
        if nonSelf[<span class="ltr">k</span>] then
         if k=='tag' then
          if type(<span class="ltr">v</span>)=='table' then
           skip[<span class="ltr">v</span>], k = 1, rawset(create(Valid(v[<span class="ltr">1</span>])), 'parent', HTML)
           Element._add(spec(parent(k.nodes, k, table.insert(nodes, k)), Element), v)
           if k.selfClosing then k.nodes = nil else spec[k.nodes], parent[k.nodes] = nil end--free memory/reduce clutter; parent ref will auto-unset when k.nodes is nil
           if not k.tagName then k.styles, k.attributes = nil end
          else table.insert(nodes, create(<span class="ltr">v</span>)) end
         elseif mwFunc[<span class="ltr">k</span>] then
          if k=='done' and tonumber(<span class="ltr">v</span>)~=v and v[<span class="ltr">1</span>] and tonumber(v[<span class="ltr">1</span>])==v[<span class="ltr">1</span>] then skip[<span class="ltr">v</span>] = 1 end
          MBmix(outFuncs[<span class="ltr">k</span>](nodes, skip[<span class="ltr">v</span>] and v[<span class="ltr">1</span>]).nodes, v)
         elseif v[<span class="ltr">1</span>] or v[<span class="ltr">2</span>] then
          k = MBi[<span class="ltr">k</span>](nodes, unpack(v, 1, rawset(skip, v, k=='_B' and 1 or 2)[<span class="ltr">v</span>]))
          Element._add(getmetatable(<span class="ltr">k</span>) and rawget(k, 'nodes') or k, v)--if k is not a table, then v should not contain any extra keys or this may error.
         else MBi[<span class="ltr">k</span>](nodes, v) end--k probably == '_G' or '_R'
        elseif mwFunc[<span class="ltr">k</span>] then
         if type(<span class="ltr">v</span>)~='table' or rawget(v, 'nodes') then mwFunc[<span class="ltr">k</span>](HTML, v)
         else
          local css = k=='css'
          for x, y in MBpairs(v, true) do (y and y~=true and mwFunc[<span class="ltr">k</span>] or noOp)(HTML, css and x:gsub('_', '-') or x, y) end--iterate non-numbers first
          for _, y in MBpairs(v, nil) do (y and y~=true and mwFunc[<span class="ltr">k</span>] or noOp)(HTML, y) end--don't bother with gsub since text must be quoted anyhow
         end
        elseif rawget(Element, k) or rawget(MBi, k) then
         if tonumber(<span class="ltr">v</span>)==v or v[<span class="ltr">1</span>]==nil or getmetatable(<span class="ltr">v</span>) then (Element[<span class="ltr">k</span>] or MBi[<span class="ltr">k</span>])(nodes, v)--v is probably string-able object, or a table to be handled by :_all
         else (Element[<span class="ltr">k</span>] or MBi[<span class="ltr">k</span>])(nodes, unpack(v, 1, table.maxn(<span class="ltr">v</span>))) end--v is definately a table
        else mwFunc.css(HTML, k:gsub('_', '-', 1), tostring(<span class="ltr">v</span>)) end--oddly enough, :_add clocked its fastest runtime after adding auto-gsub as a feature
        skip[<span class="ltr">v</span>] = nil
       end
      end
      return nodes
     end
    }
    local tempMeta = {mode='v', copy={styles=true,attributes=true}}
    function tempMeta.__index(t, i) return tempMeta.copy[<span class="ltr">i</span>] and rawset(t, i, MBi._cc(false, 0, t.orig[<span class="ltr">i</span>]))[<span class="ltr">i</span>] or t.orig[<span class="ltr">i</span>] end
    rawkey[setmetatable(Element, {__index = outFuncs, __concat=function(Element, v) return setmetatable({nodes=spec({}, Element),orig=parent[<span class="ltr">v</span>]}, tempMeta) end})] = math.huge
   end
   function MBi:getHTML(...)
    lastBuffer = self
    if ... then
     if select('#', ...)==1 then return not rawkey[<span class="ltr">s</span>] and tostring(...):match'^_' and BHi[...] and BHi[...](lastHTML) or lastHTML(...)
     else return assert(BHi[...], ('" %s " does not match any mw.html or Buffer-mw.html function'):format(tostring(...)))(lastHTML, select(2, ...)) end
    end
    return lastHTML
   end
   function MBi:_html(...) return MBi._(self, lastHTML, select(spec[self]==Element and select('#', ...)==0 and 1 or 2, true, ...)) end
   return init(...)
  end
  function _inHTML(self, ...)
   local HTML = init(nil, ...)
   if HTML.selfClosing and spec[self]==Element then self.last_concat = table.insert(self, HTML) return self end
   lastBuffer, lastHTML = self, setmetatable(parent(HTML, self), buffHTML)--set after 'args' table processed by :_add
   return HTML
  end
 end
 local _var, unbuild do local prev, rebuild
  local function init(...)--init replaced before return
   local function pick(b, v) return b and table.insert(b, v) or v end
   local function c(a, num) return rawset(a.a or a, 0, a[0] and a[0] + a.c or num and a[<span class="ltr">1</span>] or a[<span class="ltr">1</span>]:byte())[0] end
   local same, build, alt = {__tostring = function(a, b) return a.a[0] and pick(b, a.a.string and string.char(a.a[0]) or a.a.table and a.a[<span class="ltr">1</span>][a.a[0]] or a.a[0]) end}, {
    __index = {c = 1},
    __tostring = function(<span class="ltr">t</span>) return t:_build() end,
    table = function(a, b) local i = next(a[<span class="ltr">1</span>], a[0]) or a[0]==#a[<span class="ltr">1</span>] and next(a[<span class="ltr">1</span>]) return pick(b, rawset(a.a or a, 0, i)[<span class="ltr">1</span>][<span class="ltr">i</span>]) end,--change rate (a.c) ignored since users control the table's contents
    number = function(a, b) return pick(b, c(a, true)) end,
    string = function(a, b) return pick(b, string.char(c(<span class="ltr">a</span>))) end
   }, {__index = function(a, i) return a.a[<span class="ltr">i</span>] end, __tostring = function(a, b) return (rawget(a, 0) and a[0]==tostring(a[0]) and rawset(a, 0, a[0]:byte()) or a).a._build(a, b) end}
   local function shift(t, c)
    t[0] = t[0] and t[0] + c or t:_build() and t[0] - t.c + c
    if t.table then t[0] = (t[0] - 1) % #t[<span class="ltr">1</span>] + 1 end
   end
   function rebuild(...)
    local v, c = ...
    if v or select('#', ...)==0 then
     if v and not c then return prev end
     local meta, c = select(v and 1 or 3, alt, c, same, 0)
     return setmetatable({a = prev, _build = meta.__tostring, c = c}, meta)
    elseif v==nil then--no-op
    elseif c then shift(prev, c)--v == false
    else prev:_build() end
   end
   init, noCache = function(v, c) prev = setmetatable({v, c = c, _build = build[type(<span class="ltr">v</span>)] or v, [type(<span class="ltr">v</span>)] = true, alt = {}}, build) return prev end, true
   return init(...)
  end
  function unbuild(sep)
   for k, v in MBpairs(sep, nil) do
    k = getmetatable(<span class="ltr">v</span>) if k and (k==build or k==alt) then shift(v.a or v, -v.c) end
   end
  end
  function _var(self, ...)
   local obj if ... and ...~=true then obj = init(...)
   elseif prev then
    if ...~=false then obj = rebuild(...)
    else rebuild(...) end
   end
   return obj and MBi._(self, obj, nil, true) or self
  end
 end
 local lib; MBi = setmetatable({stream = _stream,
  _inHTML = _inHTML,
  _var = _var,
  _ = function(self, v, ...)
   local at, raw = select(select('#', ...)==1 and ...==true and 1 or 2, nil, ...)
   if raw then rawkey[self] = math.huge else v = Valid(<span class="ltr">v</span>) end
   if v or raw then
    if at or rawkey[self] then raw = #self end--if length increases by more than one after table.insert, then set rawkey[self] = math.huge; rawkey[self] may be equal to a previous 'at'
    at, self.last_concat = at and (tonumber(<span class="ltr">at</span>)~=at and raw + at or at)
    table.insert(self, select(at and 1 or 2, at, v))
    if at and at < 0 or raw and #self - raw > 1 then rawkey[self] = math.huge elseif at and #self==raw then rawkey[self] = rawkey[self] and math.max(rawkey[self], at) or at end
   end--above line looks bizarre because one table.insert op may make length jump from 0 to 8: local wtf={[<span class="ltr">2</span>]=2,[<span class="ltr">4</span>]=4,[<span class="ltr">8</span>]=8}mw.log(#wtf,table.insert(wtf,1),#wtf)
   return self
  end,
  _nil = function(self, at, ...)
   if ...~=true and ...~=false then--faster than type(...) ~= 'boolean'
    if not at or at=='0' then
     self[#self] = ... if ... then rawkey[self] = math.huge end
    else
     local n, v = tonumber(<span class="ltr">at</span>), ...
     if n~=at then 
      if n then n = #self + at
      elseif at~=true and select('#', ...)==0 then v, n = at, #self end
     end
     if n then 
      if v==nil and n > 0 then table.remove(self, n)
      else self[math.floor(<span class="ltr">n</span>)], rawkey[self] = v, math.huge end--floor position for consistency with Table library
     end
    end
    self.last_concat = nil
   end
   return self
  end,
  _all = function(self, t, valKey)
   for k, v in MBpairs(<span class="ltr">t</span>) do MBmix(self, v, valKey) end
   for k, v in valKey and MBpairs(t, false) or noOp, t do
    if tonumber(<span class="ltr">v</span>) then MBi._(self, k, v)--self not always a buffer
    elseif rawget(MBi, k) and v and v~=true then
     if v[<span class="ltr">1</span>]==nil or getmetatable(<span class="ltr">v</span>) then MBi[<span class="ltr">k</span>](self, v)
     else MBi[<span class="ltr">k</span>](self, unpack(v, 1, table.maxn(<span class="ltr">v</span>))) end
    end
   end
   return self
  end,
  _str = function(t, ...)
   local n = select('#', ...)
   if n > 1 then
    local k, ops, seps, r = 2, MBselect(n, ...)
    r = MB(t(seps[<span class="ltr">1</span>]))
    while parent[<span class="ltr">t</span>] and ops > 1 and r:_(parent[<span class="ltr">t</span>](seps[<span class="ltr">k</span>]), 1) do t, k, ops = parent[<span class="ltr">t</span>], k + 1, ops - 1 end
    return table.concat(r, seps[<span class="ltr">k</span>] or nil)
   end
   return MB.__call(t, ...)
  end,
  _in = function (self, ...) return parent(MB(...), self) end,
  _out = function(t, ...)
   if ...==0 then return parent(t, parent[<span class="ltr">t</span>], MBi._cc(t, t, MB.__call(t, (select(2, ...))), getmetatable(<span class="ltr">t</span>))) end--love how :_cc needed nothing new to implement this *self pat on back*
   local n = select('#', ...)
   if n > 1 then
    local k, ops, seps = 1, MBselect(n, ...)
    while parent[<span class="ltr">t</span>] and ops > 0 do t, k, ops = parent[<span class="ltr">t</span>]:_(t(seps[<span class="ltr">k</span>])), k + 1, ops - 1 end
   elseif parent[<span class="ltr">t</span>] then return parent[<span class="ltr">t</span>]:_(t(...)) end
   return t
  end,
  _cc = function(self, clear, copy, meta)
   if clear then
    if rawequal(clear, copy) then return self, spec[MBi._cc] and setmetatable(spec[MBi._cc], MB)--rawequal to avoid re-string via __eq in case both are different Buffer objects
    elseif copy==true then copy = self end
    if clear~=0 then
     assert(type(clear)=='table', debug.traceback('Buffer:_cc can only "clear" tables. Did you forget to call with a colon?', 2))--errors can be hard to trace without this
     for k in self and next or noOp, clear do rawset(clear, k, nil) end
    else return MBi._cc(false, {unpack(copy)}, copy) end--copy length w/o empty strings; recursion to avoid self = false causing garbage collection (non-weak child may exist)
    if self==false or copy and type(copy)=='table' then--self==false means copy is a table (saves a type op for recursive calls)
     meta = meta or getmetatable(copy)
     if self and #copy > 1 then--preserves length with empty strings; developed from studying http://www.lua.org/source/5.1/ltable.c.html  
      local n, null, i, e = #copy, {}, math.ldexp(2, select(2, math.frexp(#copy)) - 2)
      e, spec[MBi._cc], parent[null] = i - 1, null, clear
      for k = 1, e do table.insert(clear, false) end
      while i<=n do table.insert(clear, i, '') i, null[<span class="ltr">i</span>] = i + math.ldexp(2, select(2, math.frexp(n - i)) - 2), '' end
      for k = 1, e do rawset(clear, k, nil) end
     end
     for k, v in next, copy do rawset(clear, k, type(<span class="ltr">v</span>)=='table' and MBi._cc(false, 0, v) or v) end
    elseif copy then rawset(clear, 1, (Valid(copy))) end
    rawkey[setmetatable(clear, meta)], parent[clear] = rawkey[copy], parent[copy]
   end
   return self and rawset(self, 'last_concat', nil) or clear
  end,
  _parent = function(self, ...) return parent[self] and MBi._(self, parent[self]:_str(...)) or self end,
  getParent = function(self, ...) return isMBfunc(parent[self] or parent[parent(self, setmetatable({}, MB))], ...) end,
  killParent = function(self, ...) return parent[self] and isMBfunc(parent[self], ...) and parent(self) or self end,
  _build = function(self, t) table.insert(t, self()) end,--for compatibility with mw.html:node()
  last_concat = false--prevent library check
 }, {__index = function(t, i)--import string, mw.text, and mw.ustring libraries on an as-needed basis
  local func = string[<span class="ltr">i</span>] or mw.text[<span class="ltr">i</span>] or mw.ustring[<span class="ltr">i</span>] or type(<span class="ltr">i</span>)=='string' and mw.ustring[i:match'^u(.+)'] if func then
   lib = lib or function (s, f, ...)
    if parent[<span class="ltr">s</span>] and next(<span class="ltr">s</span>)==nil then return s:_((f(tostring(parent[Element and (spec[<span class="ltr">s</span>]==Element and s:allDone() or spec[parent[<span class="ltr">s</span>]]==Element and parent[<span class="ltr">s</span>]) or s]), ...))) end
    return f(tostring(<span class="ltr">s</span>), ...)--not using ternary/logical operators here to allow multiple return values
   end
   return rawset(t, i, i:match'^u?gsub' and function(self, p, r, ...)return lib(self, func, p, r or '', ...)end--Why are ugsub/gsub special? because empty strings are against my religion!
    or function(self, ...)return lib(self, func, ...)end)[<span class="ltr">i</span>]
  end
 end})
end

function MBmix(t, v, ...) return v and ((type(<span class="ltr">v</span>)~='table' or getmetatable(<span class="ltr">v</span>)) and MBi._(t, v) or (select('#', ...)==0 and spec[<span class="ltr">t</span>] and spec[<span class="ltr">t</span>]._add or MBi._all)(t, v, ...)) or t end--:_all always passes two args

local _G, new_G = _G--localize _G for console testing (console _G ~= module _G)
return setmetatable({__index = function(t, i) return spec[<span class="ltr">t</span>] and spec[<span class="ltr">t</span>][<span class="ltr">i</span>] or MBi[<span class="ltr">i</span>] end,
 __call = function(t, ...)
  local rawsep, sep, i, j, raw = noCache and rawkey[...] and ..., ...
  if i or j or rawsep or Valid(sep) then
   raw, sep, i, j = rawkey[spec[<span class="ltr">t</span>]] or rawkey[<span class="ltr">t</span>], rawsep or Valid(sep), i and (i~=tonumber(<span class="ltr">i</span>) and i + #t or i), j and (j~=tonumber(<span class="ltr">j</span>) and j + #t or j)
   if rawsep or raw and (raw>=(j or #t) or i <<span class="ltr">1</span>) then
    raw, i, j = {}, i and math.floor(<span class="ltr">i</span>), j and math.floor(<span class="ltr">j</span>)--floor for consistency with table.concat(t, sep, i, j), which ignores decimals
    raw.lc, t.last_concat = t.last_concat--temporarily unset last_concat to prevent disqualification from mapless iteration
    for k, v in MBpairs(<span class="ltr">t</span>) do
     if raw[<span class="ltr">1</span>] or not i or k>=i then if j and k > j then break end
      if raw.s then raw.s = table.insert(raw, tostring(sep)) end--if sep contains v and v is a Buffer-variable, sep must be strung before v
      k = Valid(<span class="ltr">v</span>) if k then
       raw.s = rawsep or sep and raw[<span class="ltr">1</span>] and table.insert(raw, sep)
       table.insert(raw, k)
      end
     end
    end
    if rawsep and not raw.s then raw[#raw] = unbuild(sep) end--unbuild rawsep if final index in t was invalid
    t.last_concat = raw.lc return table.concat(raw)
   end
   return table.concat(t, sep, i and math.max(i, 1), j and math.min(j, #t))
  end
  return MB.__tostring(<span class="ltr">t</span>)
 end,
 __tostring = function(<span class="ltr">t</span>)
  if t.last_concat then return t.last_concat end
  local r = rawkey[spec[<span class="ltr">t</span>]] or rawkey[<span class="ltr">t</span>]
  r = table.concat(r and r>=#t and MBi._all({}, t) or t)
  return (noCache or rawset(t, 'last_concat', r)) and r
 end,
 __concat = function(a, b)
  if buffHTML then
   for k = 1, 2 do local v = select(k, a, b)--faster than for k, v in pairs{a, b} do
    if v and spec[<span class="ltr">v</span>] and spec[<span class="ltr">v</span>]==Element then
     if parent[<span class="ltr">v</span>].selfClosing then
      if rawequal(a, b) then return (not noCache or parent[<span class="ltr">v</span>].tagName) and v:_str(0):rep(<span class="ltr">2</span>) or v:_str(0)..v:_str(0) end--rawequal avoids premature tostring of Buffer:_var objects;
      b, a = select(k, b, parent[<span class="ltr">v</span>], a)
     else local temp = Element .. v --helper method; returns a mirror of parent[<span class="ltr">v</span>]
      MBmix(MBmix(parent(temp.nodes, temp), a), k==1 and spec[<span class="ltr">b</span>]==Element and parent[<span class="ltr">b</span>] or b)
      return buffHTML.__tostring(setmetatable(temp, {__index=parent[<span class="ltr">v</span>], __mode='v'}))--switch from tempMeta to avoid MBi._cc op of styles/attributes
     end
    end
   end
  end
  return table.concat(MBmix(MBmix({}, a), b))
 end,
 __pairs = MBpairs,
 __ipairs = MBpairs,
 __eq = function(a, b) return tostring(<span class="ltr">a</span>)==tostring(<span class="ltr">b</span>) end--avoid a==b in this module; use rawequal(a,b) when they may be different Buffers (premature tostring waste ops and is bad for Buffer:_var)
}, {__tostring = function()return''end,
 __call = function(self, ...) MB = MB or self
  if new_G then if ... and _G and ...==_G then new_G = ... end
  elseif ... and (...==_G or type(...)=='table' and (...)._G==...) then
   local Nil, mG = {}, (...):getmetatable() or (...):setmetatable{}:getmetatable()
   new_G, _G, gfuncs = ..., ..., {--gfuncs stored for Buffer:_inHTML; new_G is a is a Module:Buffer local declared just before the final return statement.
    _G = function(self, i, ...)
     local X, save = rawget(new_G, i), select('#', ...)==0 and self or ...
     if i and i~=true and not (X and save and rawequal(X, save)) and rawset(new_G, i, save) and (X~=nil or save==nil and new_G[<span class="ltr">i</span>]~=nil) then--rawequal in case X is another buffer
      local mG = getmetatable(new_G) or {__call=mG.__call}
      if mG.__index then pcall(rawset, mG.__index, i, X)
      else mG.__index = setmetatable(new_G, mG) and {[<span class="ltr">i</span>] = X} end
     end
     return self, ...--avoiding __eq with rawequal(self,save) is overkill since buffers can self-save without being passed as save
    end,
    _R = function(self, i, v, m)
     if i~='new_G' then if i and i~=true then rawset(new_G, i , v) end
     elseif not v or v==true or v._G~=_G then new_G = setmetatable(v~=true and v or {}, {__call = mG.__call, __index = v~=true and m~=true and (m or new_G) or nil})
     else new_G, (not m and (m~=nil or v==new_G) and Nil or getmetatable(<span class="ltr">v</span>)).__index = v, m~=true and (m or new_G) or nil end--setting Nil.__index is noOp
     return self
    end,
    _2 = function(self, ...)
     if new_G[...]~=nil then return new_G[...] end--higher priority so Buffer:_G('new_G', ...) can prevent an overwrite
     if ...=='new_G' then return rawset((select('#', ...)~=1 and MBi._R(new_G, ...) or new_G), '_G', _G) end
     return select(select('#', ...)==1 and 1 or 2, self:_G(...))--return only one value; 'return select(2, self:_G(...)) or self' doesn't work for returning nil
    end,
    _B = function(self, v) return v or v==nil and Nil end
   } for k, v in next, gfuncs do MBi[<span class="ltr">k</span>] = v end 
   setmetatable(Nil,{__concat=MB.__concat,__newindex=noOp,__call=noOp,__tostring=noOp,__metatable=MB,__index=setmetatable({_B=MBi._B,_=function()return Nil end,last_concat=''},
    {__index=function(t,i)return (MBi[<span class="ltr">i</span>] or i and not tonumber(<span class="ltr">i</span>)) and t._ or nil end})})
   function mG.__call(G, k, ...) return (k._G or G.type(<span class="ltr">k</span>)=='table') and (G.select('#', ...)~=1 and G.rawset(k, ...) or G:rawset(..., k) and k) or G:rawset(k, (...)) and ... end
  end
  local new = setmetatable({}, self)
  if ... and (...)==new_G then return select(2, ...) and MBmix(new:_G((select(2, ...))), select(3, ...)) or new end
  return ... and MBi._(new, ...) or new
 end,
 __index = function(t, i)
  MB = MB or t return MBi[<span class="ltr">i</span>] and function(...) return MBi[<span class="ltr">i</span>](setmetatable({}, t), select(...==t and 2 or 1,...)) end
 end
})
●