wtf_wikipedia.mjs

/*! wtf_wikipedia  MIT */
import unfetch from 'isomorphic-unfetch';

/**
 * Parses out the domain and title from a url
 *
 * @private
 * @param {string} url The url that will be parsed
 * @returns {{domain: string, title: string}} The domain and title of a url
 */
const parseUrl = function (url) {
  let parsed = new URL(url); // eslint-disable-line
  let title = parsed.pathname.replace(/^\/(wiki\/)?/, '');
  title = decodeURIComponent(title);
  return {
    domain: parsed.host,
    title: title,
  }
};

/**
 * capitalizes the input
 * hello -> Hello
 * hello there -> Hello there
 *
 * @private
 * @param {string} [str] the string that will be capitalized
 * @returns {string} the capitalized string
 */

/**
 * trim whitespaces of the ends normalize 2 spaces into one and removes whitespaces before commas
 *
 * @private
 * @param {string} [str] the string that will be processed
 * @returns {string} the processed string
 */
function trim_whitespace(str) {
  if (str && typeof str === 'string') {
    str = str.replace(/^\s+/, '');
    str = str.replace(/\s+$/, '');
    str = str.replace(/ {2}/, ' ');
    str = str.replace(/\s, /, ', ');
    return str
  }
  return ''
}

/**
 * determines if an variable is an array or not
 *
 * @private
 * @param {*} x the variable that needs to be checked
 * @returns {boolean} whether the variable is an array
 */
function isArray(x) {
  return Object.prototype.toString.call(x) === '[object Array]'
}

/**
 *  determines if an variable is an object or not
 *
 * @private
 * @param {*} x the variable that needs to be checked
 * @returns {boolean} whether the variable is an object
 */
function isObject(x) {
  return x && Object.prototype.toString.call(x) === '[object Object]'
}

const isInterWiki =
  /(wikibooks|wikidata|wikimedia|wikinews|wikipedia|wikiquote|wikisource|wikispecies|wikiversity|wikivoyage|wiktionary|foundation|meta)\.org/;

const defaults$c = {
  action: 'query',
  prop: 'revisions|pageprops', // we use the 'revisions' api here, instead of the Raw api, for its CORS-rules..
  rvprop: 'content|ids|timestamp',
  maxlag: 5,
  rvslots: 'main',
  origin: '*',
  format: 'json',
  redirects: 'true',
};

/**
 * turns a object into a query string
 *
 * @private
 * @param {Object<string, string | number | boolean>} obj
 * @returns {string} QueryString
 */
const toQueryString = function (obj) {
  return Object.entries(obj)
    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
    .join('&')
};

/**
 * cleans and prepares the tile by replacing the spaces with underscores (_) and trimming the white spaces of the ends
 *
 * @private
 * @param {string} page the title that needs cleaning
 * @returns {string} the cleaned title
 */
const cleanTitle = (page) => {
  return page.replace(/ /g, '_').trim()
};

/**
 * generates the url for fetching the pages
 *
 * @private
 * @param {import('.').fetchDefaults} options
 * @param {Object} [parameters]
 * @returns {string} the url that can be used to make the fetch
 */
const makeUrl = function (options, parameters = defaults$c) {
  let params = Object.assign({}, parameters);

  //default url
  let apiPath = '';

  //add support for third party apis
  if (options.domain) {
    //wikimedia is the only api that uses `/w/api` as its path. other wikis use other paths
    let path = isInterWiki.test(options.domain) ? 'w/api.php' : options.path;
    apiPath = `https://${options.domain}/${path}?`;
  } else if (options.lang && options.wiki) {
    apiPath = `https://${options.lang}.${options.wiki}.org/w/api.php?`;
  } else {
    return ''
  }

  if (!options.follow_redirects) {
    delete params.redirects;
  }

  // the origin header and url parameters need to be the same
  // if one is provided we should change both the header and the parameter
  if (options.origin) {
    params.origin = options.origin;
  }

  //support numerical ids
  let title = options.title;
  if (typeof title === 'number') {
    //single pageId
    params.pageids = title;
  } else if (typeof title === 'string') {
    //single page title
    params.titles = cleanTitle(title);
  } else if (title !== undefined && isArray(title) && typeof title[0] === 'number') {
    //pageid array
    params.pageids = title.filter((t) => t).join('|');
  } else if (title !== undefined && isArray(title) === true && typeof title[0] === 'string') {
    //title array
    params.titles = title
      .filter((t) => t)
      .map(cleanTitle)
      .join('|');
  } else {
    return ''
  }

  //make it!
  return `${apiPath}${toQueryString(params)}`
};

/**
 * parses the media wiki api response to something we can use
 *
 * the data-format from mediawiki api is nutso
 *
 * @private
 * @param {object} data
 * @param {object} [options]
 * @returns {*} result
 */
const getResult = function (data, options = {}) {
  // handle nothing found or no data passed
  if (!data?.query?.pages || !data?.query || !data) {
    return null
  }

  //get all the pagesIds from the result
  let pages = Object.keys(data.query.pages);

  // map over the pageIds to parse out all the information
  return pages.map((id) => {
    // get the page by pageID

    let page = data.query.pages[id] || {};

    // if the page is missing or not found than return null
    if (page.hasOwnProperty('missing') || page.hasOwnProperty('invalid')) {
      return null
    }

    // get the text from the object
    let text = page.revisions[0]['*'];
    // if the text is not found in the regular place than it is at the other place
    if (!text && page.revisions[0].slots) {
      text = page.revisions[0].slots.main['*'];
    }
    let revisionID = page.revisions[0].revid;
    let timestamp = page.revisions[0].timestamp;

    page.pageprops = page.pageprops || {};

    let domain = options.domain;
    if (!domain && options.wiki) {
      domain = `${options.wiki}.org`;
    }

    let meta = Object.assign({}, options, {
      title: page.title,
      pageID: page.pageid,
      namespace: page.ns,
      domain,
      revisionID,
      timestamp,
      pageImage: page.pageprops['page_image_free'],
      wikidata: page.pageprops.wikibase_item,
      description: page.pageprops['wikibase-shortdesc'],
    });

    return { wiki: text, meta: meta }
  })
};

/**
 * helper for looping around all sections of a document
 *
 * @private
 * @param {object} doc the document with the sections
 * @param {string} fn the function name of the function that will be called
 * @param {string | number} [clue] the clue that will be used with the function
 * @returns {Array|*} the array of item at the index of the clue
 */
const sectionMap = function (doc, fn, clue) {
  let arr = [];
  doc.sections().forEach((sec) => {
    let list = [];
    if (typeof clue === 'string') {
      list = sec[fn](clue);
    } else {
      list = sec[fn]();
    }
    list.forEach((t) => {
      arr.push(t);
    });
  });
  if (typeof clue === 'number') {
    if (arr[clue] === undefined) {
      return []
    }
    return [arr[clue]]
  }
  return arr
};

/**
 * applies the the key values of defaults to options
 *
 * @private
 * @param {object} options the user options
 * @param {object} defaults the defaults
 * @returns {object} the user options with the defaults applied
 */
const setDefaults = function (options, defaults) {
  return Object.assign({}, defaults, options)
};

/**
 * @typedef DocumentToJsonOptions
 * @property {boolean | undefined} title
 * @property {boolean | undefined} pageID
 * @property {boolean | undefined} categories
 * @property {boolean | undefined} sections
 * @property {boolean | undefined} coordinates
 * @property {boolean | undefined} infoboxes
 * @property {boolean | undefined} images
 * @property {boolean | undefined} plaintext
 * @property {boolean | undefined} citations
 * @property {boolean | undefined} references
 */
const defaults$b = {
  title: true,
  sections: true,
  pageID: true,
  categories: true,
  wikidata: true,
  description: true,
  revisionID: false,
  timestamp: false,
  pageImage: false,
  domain: false,
  language: false,
};

/**
 * @typedef documentToJsonReturn
 * @property {string | undefined} title
 * @property {number | null | undefined} pageID
 * @property {string[] | undefined} categories
 * @property {object[] | undefined} sections
 * @property {boolean | undefined} isRedirect
 * @property {object | undefined} redirectTo
 * @property {object[] | undefined} coordinates
 * @property {object[] | undefined} infoboxes
 * @property {object[] | undefined} images
 * @property {string | undefined} plaintext
 * @property {object[] | undefined} references
 */

/**
 * an opinionated output of the most-wanted data
 *
 * @private
 * @param {object} doc
 * @param {DocumentToJsonOptions} options
 * @returns {documentToJsonReturn}
 */
const toJSON$2 = function (doc, options) {
  options = setDefaults(options, defaults$b);

  /**
   * @type {documentToJsonReturn}
   */
  let data = {};

  if (options.title) {
    data.title = doc.title();
  }

  // present only if true
  if (doc.isRedirect() === true) {
    data.isRedirect = true;
    data.redirectTo = doc.redirectTo();
    data.sections = [];
  }
  if (doc.isStub() === true) {
    data.isStub = true;
  }
  if (doc.isDisambiguation() === true) {
    data.isDisambiguation = true;
  }

  // metadata
  if (options.pageID && doc.pageID()) {
    data.pageID = doc.pageID();
  }
  if (options.wikidata && doc.wikidata()) {
    data.wikidata = doc.wikidata();
  }
  if (options.revisionID && doc.revisionID()) {
    data.revisionID = doc.revisionID();
  }
  if (options.timestamp && doc.timestamp()) {
    data.timestamp = doc.timestamp();
  }
  if (options.description && doc.description()) {
    data.description = doc.description();
  }

  // page sections
  if (options.categories) {
    data.categories = doc.categories();
  }
  if (options.sections) {
    data.sections = doc.sections().map((i) => i.json(options));
  }
  if (options.infoboxes) {
    data.infoboxes = doc.infoboxes().map((i) => i.json(options));
  }
  if (options.images) {
    data.images = doc.images().map((i) => i.json(options));
  }
  if (options.citations || options.references) {
    data.references = doc.references();
  }
  if (options.coordinates) {
    data.coordinates = doc.coordinates();
  }

  if (options.plaintext) {
    data.plaintext = doc.text(options);
  }

  return data
};

var _categories = [
  'category', //en

  'abdeeling', //	pdc
  'bólkur', //	fo
  'catagóir', //	ga
  'categori', //	cy
  'categoria',
  'categoria', //	co
  'categoría', //	es
  'categorîa', //	lij
  'categorìa', //	pms
  'catégorie',
  'categorie',
  'catègorie', //	frp
  'category',
  'categuria', //	lmo
  'catigurìa', //	scn
  'class', //	kw
  'ẹ̀ka', //	yo
  'flocc',
  'flocc', //	ang
  'flokkur',
  'grup', //	tpi
  'jamii', //	sw
  'kaarangay', //	war
  'kateggoría', //	lad
  'kategooria', //	et
  'kategori', //	da
  'kategorî', //	ku
  'kategoria', //	eu
  'kategória', //	hu
  'kategorie', //de
  'kategoriija', //	se
  'kategorija', //	sl
  'kategorio', //	eo
  'kategoriya',
  'kategoriýa', //	tk
  'kategoriye', //	diq
  'kategory', //	fy
  'kategorya', //	tl
  'kateqoriya', //	az
  'katiguriya', //	qu
  'klad', //	vo
  'luokka',
  'ñemohenda', //	gn
  'roinn', //-seòrsa	gd
  'ronney', //	gv
  'rummad', //	br
  'setensele', //	nso
  'sokajy', //	mg
  'sumut', // atassuseq	kl
  'thể', // loại	vi
  'turkum', //	uz
  'категорија',
  'категория', //	ru
  'категорія', //	uk
  'катэгорыя',
  'төркем', //	tt
  'קטגוריה', //	he
  'تصنيف',
  'تۈر', //	ug
  'رده',
  'श्रेणी',
  'श्रेणी', //	hi
  'বিষয়শ্রেণী', //	bn
  'หมวดหมู่', //	th
  '분류', //	ko
  '분류', //ko
  '分类', //	za
  //--
];

var disambig_templates = [
  'dab', //en
  'disamb', //en
  'disambig', //en
  'disambiguation', //en

  'aðgreining',
  'aðgreining', //is
  'aimai', //ja
  'airport disambiguation',
  'ałtsʼáʼáztiin', //nv
  'anlam ayrımı', //gag
  'anlam ayrımı', //tr
  'apartigilo', //eo
  'argipen', //eu
  'begriepskloorenge', //stq
  'begriffsklärung', //als
  'begriffsklärung', //de
  'begriffsklärung', //pdc
  'begriffsklearung', //bar
  'biology disambiguation',
  'bisongidila', //kg
  'bkl', //pfl
  'bokokani', //ln
  'caddayn', //so
  'call sign disambiguation',
  'caselaw disambiguation',
  'chinese title disambiguation',
  'clerheans', //kw
  'cudakirin', //ku
  'čvor', //bs
  'db', //vls
  'desambig', //nov
  'desambigación', //an
  'desambiguação', //pt
  'desambiguació', //ca
  'desambiguación', //es
  'desambiguáncia', //ext
  'desambiguasion', //lad
  'desambiguassiù', //lmo
  'desambigui', //lfn
  'dezambiguizare', //ro
  'dezanbìgua',
  'dəqiqləşdirmə',
  'dəqiqləşdirmə', //az
  'disamb-term',
  'disamb-terms',
  'disamb2',
  'disamb3',
  'disamb4',
  'disambigua', //it
  'disambìgua', //sc
  'disambiguasi',
  'disambiguation cleanup',
  'disambiguation lead name',
  'disambiguation lead',
  'disambiguation name',
  'disambiguazion',
  'disambigue',
  'discretiva',
  'discretiva', //la
  'disheñvelout', //br
  'disingkek', //min
  'dixanbigua', //vec
  'dixebra', //ast
  'diżambigwazzjoni', //mt
  'dmbox',
  'doorverwijspagina', //nl
  'dp', //nl
  'dubbelsinnig',
  'dubbelsinnig', //af
  'dudalipen', //rmy
  'dv', //nds_nl
  'egyért', //hu
  'faaleaogaina',
  'fleiri týdningar', //fo
  'fleirtyding', //nn
  'flertydig', //da
  'förgrening', //sv
  'genus disambiguation',
  'gì-ngiê', //cdo
  'giklaro', //ceb
  'gwahaniaethu', //cy
  'homonimo', //io
  'homónimos', //gl
  'homonymie', //fr
  'hospital disambiguation',
  'huaʻōlelo puana like',
  'huaʻōlelo puana like', //haw
  'human name disambiguation cleanup',
  'human name disambiguation',
  'idirdhealú', //ga
  'khu-pia̍t', //zh_min_nan
  'kthjellim', //sq
  'kujekesa', //sn
  'letter-number combination disambiguation',
  'letter-numbercombdisambig',
  'maana', //sw
  'maneo bin', //diq
  'mathematical disambiguation',
  'mehrdüdig begreep', //nds
  'menm non', //ht
  'military unit disambiguation',
  'muardüüdag artiikel', //frr
  'music disambiguation',
  'myesakãrã',
  'neibetsjuttings', //fy
  'nozīmju atdalīšana', //lv
  'number disambiguation',
  'nuorodinis', //lt
  'nyahkekaburan', //ms
  'omonimeye', //wa
  'omonimi',
  'omonimia', //oc
  'opus number disambiguation',
  'page dé frouque', //nrm
  'paglilinaw', //tl
  'panangilawlawag', //ilo
  'pansayod', //war
  'pejy mitovy anarana', //mg
  'peker', //no
  'phonetics disambiguation',
  'place name disambiguation',
  'portal disambiguation',
  'razdvojba', //hr
  'razločitev', //sl
  'razvrstavanje', //sh
  'reddaghey', //gv
  'road disambiguation',
  'rozcestník', //cs
  'rozlišovacia stránka', //sk
  'school disambiguation',
  'sclerir noziun', //rm
  'selvendyssivu', //olo
  'soilleireachadh', //gd
  'species latin name abbreviation disambiguation',
  'species latin name disambiguation',
  'station disambiguation',
  'suzmunski', //jbo
  'synagogue disambiguation',
  'täpsustuslehekülg', //et
  'täsmennyssivu', //fi
  'taxonomic authority disambiguation',
  'taxonomy disambiguation',
  'telplänov', //vo
  'template disambiguation',
  'tlahtolmelahuacatlaliztli', //nah
  'trang định hướng', //vi
  'ujednoznacznienie', //pl
  'verdudeliking', //li
  'wěcejwóznamowosć', //dsb
  'wjacezmyslnosć', //hsb
  'z',
  'zambiguaçon', //mwl
  'zeimeibu škiršona', //ltg
  'αποσαφήνιση', //el
  'айрық', //kk
  'аҵакырацәа', //ab
  'бир аайы јок',
  'вишезначна одредница', //sr
  'ибҳомзудоӣ', //tg
  'кёб магъаналы', //krc
  'күп мәгънәләр', //tt
  'күп мәғәнәлелек', //ba
  'массехк маӏан хилар',
  'мъногосъмꙑслиѥ', //cu
  'неадназначнасць', //be
  'неадназначнасьць', //be_x_old
  'неоднозначность', //ru
  'олон удхатай', //bxr
  'појаснување', //mk
  'пояснение', //bg
  'са шумуд манавал', //lez
  'салаа утгатай', //mn
  'суолталар', //sah
  'текмаанисиздик', //ky
  'цо магіна гуреб', //av
  'чеперушка', //rue
  'чолхалла', //ce
  'шуко ончыктымаш-влак', //mhr
  'მრავალმნიშვნელოვანი', //ka
  'բազմիմաստութիւն', //hyw
  'բազմիմաստություն', //hy
  'באדייטן', //yi
  'פירושונים', //he
  'ابهام‌زدایی', //fa
  'توضيح', //ar
  'توضيح', //arz
  'دقیقلشدیرمه', //azb
  'ڕوونکردنەوە', //ckb
  'سلجهائپ', //sd
  'ضد ابہام', //ur
  'گجگجی بیری', //mzn
  'نامبهمېدنه', //ps
  'መንታ', //am
  'अस्पष्टता', //ne
  'बहुअर्थी', //bh
  'बहुविकल्पी शब्द', //hi
  'দ্ব্যর্থতা নিরসন', //bn
  'ਗੁੰਝਲ-ਖੋਲ੍ਹ', //pa
  'સંદિગ્ધ શીર્ષક', //gu
  'பக்கவழி நெறிப்படுத்தல்', //ta
  'అయోమయ నివృత్తి', //te
  'ದ್ವಂದ್ವ ನಿವಾರಣೆ', //kn
  'വിവക്ഷകൾ', //ml
  'වක්‍රෝත්ති', //si
  'แก้ความกำกวม', //th
  'သံတူကြောင်းကွဲ', //my
  'သဵင်မိူၼ် တူၼ်ႈထႅဝ်ပႅၵ်ႇ',
  'ណែនាំ', //km
  'អសង្ស័យកម្ម',
  '동음이의', //ko
  '扤清楚', //gan
  '搞清楚', //zh_yue
  '曖昧さ回避', //ja
  '消歧义', //zh
  '釋義', //zh_classical
  "gestion dj'omònim", //pms
  "sut'ichana qillqa", //qu
  // 'z', //vep
  // 'သဵင်မိူၼ် တူၼ်ႈထႅဝ်ပႅၵ်ႇ', //shn
  `gestion dj'omònim`,
  `sut'ichana qillqa`,
];

// used in titles to denote disambiguation pages
// see 'Football_(disambiguation)'
var disambig_titles = [
  'disambiguation', //en
  'homonymie', //fr
  'توضيح', //ar
  'desambiguação', //pt
  'Begriffsklärung', //de
  'disambigua', //it
  '曖昧さ回避', //ja
  '消歧義', //zh
  '搞清楚', //zh-yue
  'значения', //ru
  'ابهام‌زدایی', //fa
  'د ابہام', //ur
  '동음이의', //ko
  'dubbelsinnig', //af
  'այլ կիրառումներ', //hy
  'ujednoznacznienie', //pl
];

var images = [
  'file', //en
  'image', //en
  'चित्र', //img

  'archivo', //es
  'attēls', //lv
  'berkas', //id
  'bestand', //nl
  'datei', //de
  'dosiero', //eo
  'dosya', //lad
  'fájl', //hu
  'fasciculus', //la
  'fichier', //fr
  'fil', //da
  'fitxategi', //eu
  'fitxer', //ca
  'gambar', //su
  'imagem', //pt
  'imej', //ms
  'immagine', //it
  'larawan', //tl
  'lêer', //af
  'plik', //pl
  'restr', //br
  'slika', //bs
  'wêne', //ku
  'wobraz', //dsb
  'выява', //be
  'податотека', //mk
  'слика', //sr
  'файл', //ru
  'სურათი', //ka
  'պատկեր', //hy
  'קובץ', //he
  'پرونده', //fa
  'دوتنه', //ps
  'ملف', //ar
  'وێنە', //ckb
  'चित्र', //hi
  'ไฟล์', //th
  '파일', //ko
  'ファイル', //ja
];

// https://en.m.wikipedia.org/wiki/Template:Stub#/languages
var stubs = [
  'aboç',
  'ahurhire',
  'aizmetnis',
  'amud',
  'avixo de spigaso',
  // 'begin',
  'beginnetje',
  'bibarilo',
  'borrador',
  'buáng-nàng-hâ',
  'bun',
  'buntato',
  'c-supranu',
  'cahrot',
  'chala',
  'choutchette',
  'ciot',
  'csonk',
  'cung',
  'danvez pennad',
  'djermon',
  'ébauche',
  'ébeuche',
  'ebòch',
  'édéntạ',
  'eginyn',
  'ẹ̀kúnrẹ́rẹ́',
  'en progreso',
  'entamu',
  'esboço',
  'esborrany',
  'esbòs',
  'esbozo',
  'ĝermo',
  'gumud',
  'ʻōmuku',
  'junj',
  'klado',
  'maramara',
  'mayele',
  'mbegu',
  'mrva',
  'na mulno',
  'nadabeigts rakstīņs',
  'nalta',
  'narcce',
  'pahýl',
  'pecietta',
  'phí',
  'pondok',
  'por mejoral',
  'potuʻi',
  'pungol',
  'qaralama',
  'rabisco',
  'rancangan',
  'rintisan',
  'saadjie',
  'saha',
  'sbozz',
  'sid',
  'síol',
  'şitil',
  'sjtumpke',
  'skizz',
  'skizze',
  'škrbina',
  'sơ khai',
  'spire',
  'stipula',
  'stob',
  'stobbe',
  // 'stock',
  'stompje',
  'stub',
  'stubben',
  'stubbi',
  'stubbur',
  'stump',
  'stumpen',
  'stycce',
  'suli',
  'taslak',
  'taslaq',
  'tunas',
  'turók',
  'tynkä',
  // 'u začetku',
  'vangovango',
  'vernuşte',
  'výhonok',
  'xinnoo',
  'zarodk',
  'zirriborroa',
  'επέκταση',
  'әҙерләмә',
  'заготовка',
  'керф',
  'кечдар',
  'клица',
  'къæртт',
  'кьурхь',
  'мәкалә төпчеге',
  'мъниче',
  'накід',
  'нєꙁаврьшєнъ члѣнъ',
  'никулец',
  'омоон',
  'стыржень',
  'хурд',
  'хӏадурунжо',
  'ესკიზი',
  'መዋቅር',
  'መዋቕር',
  'अपूर्णलेखः',
  'आधार',
  'ठुटो',
  'धाक्टें पान',
  'विस्तार',
  'অসম্পূর্ণ',
  'পোখালি',
  'સ્ટબ',
  'ଅଧାଗଢ଼ା',
  'குறுங்கட்டுரை',
  'మొలక',
  'ಎಲ್ಯ',
  'ಚುಟುಕು',
  'അപൂർണ്ണം',
  'අංකුරය',
  'โครง',
  'ཆ་མི་ཚང་བ',
  'អត្ថបទខ្លីមិនពេញលេញ',
  '토막글',
  '楔',
  '芻文',
];

var infoboxes$1 = [
  'infobox', //en

  'amatl',
  'anfo', //mwl
  'anuāmapa', //haw
  'bilgi kutusu', //tr
  'bilgi', //tr
  'bilgiquti', //uz
  'boaty fampahalalana',
  'boaty', //mg
  'boestkelaouiñ', //br
  'bosca', //ga
  'capsa', //la
  'diehtokássa', //se
  'faktamall', //sv
  'ficha', //es
  'generalni', //hr
  'gwybodlen3', //cy
  'hộp thông tin',
  'info', //pt
  'infoboesse 2',
  'infobokis', //tpi
  'infoboks', //da
  'infobox deleted',
  'infobox generic',
  'infobox generiek',
  'infochascha', //rm
  'infokašćik', //dsb
  'infokast', //et
  'infokutija', //bs
  'infolentelė', //lt
  'infookvir',
  'infopolje', //sl
  'informkesto', //eo
  'infoschede',
  'infoskreine', //ltg
  'infotaula', //eu
  'inligtingskas',
  'inligtingskas3', //af
  'inligtingskas4', //af
  'kishtey fys',
  'kotak info',
  'kotak', //su
  'məlumat qutusu',
  'simple box',
  'tertcita tanxe',
  'tertcita', //jbo
  'tiätuloová',
  'tietolaatikko', //fi
  'wd bosca sonraí',
  'yerleşim bilgi kutusu',
  'ynfoboks generyk',
  'ynfoboks', //fy
  'πλαίσιο πληροφοριών',
  'πλαίσιο', //el
  'акарточка', //ab
  'аҥа', //mhr
  'инфобокс', //kk
  'инфокутија', //sr
  'инфокутия', //bg
  'інфобокс', //rue
  'канадский',
  'картка', //be
  'карточка', //ru
  'карточка2', //mdf
  'карточкарус', //ba
  'картуш', //koi
  'қуттӣ', //tg
  'ინფოდაფა', //ka
  'տեղեկաքարտ', //hy
  'תבנית', //he
  'بطاقة', //ar
  'ڄاڻخانو', //sd
  'خانہ', //ur
  'لغة',
  'معلوٗمات ڈَبہٕ',
  'ज्ञानसन्दूक', //hi
  'তথ্যছক', //bn
  'ਜਾਣਕਾਰੀਡੱਬਾ', //pa
  'సమాచారపెట్టె', //te
  'තොරතුරුකොටුව', //si
  'กล่องข้อมูล', //th
  'ກ່ອງຂໍ້ມູນ',
  'ប្រអប់ព័ត៌មាន', //km
  '정보상자', //ko
  '明細', //zh_yue
];

var redirects = [
  'aanstuur', //af
  'aastiurey',
  'adkas', //br
  'ailgyfeirio',
  'alidirekto',
  'alih', //id
  'aýdaw',
  'baw-ing',
  'beralîkirin', //ku
  'birzuzendu',
  'đổi hướng đến đây',
  'doorverwijzing', //nl
  'header',
  'i̇stiqamətləndirmə',
  'lencong', //ms
  'ohjaa tänne',
  'ohjaus',
  'omdirigering', //no
  'pāradresācija',
  'patrz', //pl
  'přesměrování',
  'přesměruj',
  'preusmeritev',
  'preusmjerava',
  'preusmjerenje',
  'preusmjeri', //hr
  'przekierowanie',
  'redir',
  'redirecció',
  'redireccion',
  'redirección', //es
  'redirecionamento', //pt
  'redirect', //en
  'redirect3',
  'redirection', //fr
  'redirige aquí',
  'redirige',
  'redirixe equí',
  'rindirizz',
  'rinvia', //it
  'stivre deike',
  'suunamine',
  'tilvísun',
  'trimite',
  'uudelleenohjaus',
  'weiterleitung', //de
  'weiterleitungshinweis',
  'yoʻnaltirish',
  'yönlendi̇r',
  'yönlendi̇rme', //tr
  'ανακατευθυνση', //el
  'айдау', //kk
  'багыттама',
  'буссинаби',
  'дӏасахьажорг',
  'от пренасочване',
  'перанакіраванне',
  'перанакіраваньне',
  'перанакіроўваецца сюды',
  'перенаправление', //ru
  'перенаправлення', //uk
  'перенаправлено',
  'пренасочување', //mk
  'преусмерава ',
  'преусмери', //sr
  'преусмјери',
  'равонакунӣ',
  'ווייטערפירן', //yi
  'تحويل', //ar
  'تغییر_مسیر',
  'تغییرمسیر', //fa
  'رجوع مکرر', //ur
  'رجوع_مکرر', //ur
  'अनुप्रेषित', //hi
  'पुनर्निर्देशन', //hi
  'পুননির্দেশ', //bn
  'পুনর্নির্দেশ',
  'යළියොමුව',
  'เปลี่ยนทาง',
  'ប្តូរទីតាំងទៅ', //km
  '다른 뜻 넘어옴',
  'リダイレクト', //ja
  '跳轉',
  '転送', //ja
  '重定向', //zh
];

var references = [
  'references',
  'reference',
  'einzelnachweise',
  'referencias',
  'références',
  'notes et références',
  '脚注',
  'referenser',
  'bronnen',
  'примечания',
];

//alt disambig-templates en-wikipedia uses
let d = ' disambiguation';
const templates$d = [
  'dab',
  'dab',
  'disamb',
  'disambig',
  'geodis',
  'hndis',
  'setindex',
  'ship index',
  'split dab',
  'sport index',
  'wp disambig',
  'disambiguation cleanup',
  'airport' + d,
  'biology' + d,
  'call sign' + d,
  'caselaw' + d,
  'chinese title' + d,
  'genus' + d,
  'hospital' + d,
  'lake index',
  'letter' + d,
  'letter-number combination' + d,
  'mathematical' + d,
  'military unit' + d,
  'mountainindex',
  'number' + d,
  'phonetics' + d,
  'place name' + d,
  'portal' + d,
  'road' + d,
  'school' + d,
  'species latin name abbreviation' + d,
  'species latin name' + d,
  'station' + d,
  'synagogue' + d,
  'taxonomic authority' + d,
  'taxonomy' + d,
].reduce((h, str) => {
  h[str] = true;
  return h
}, {});

const mayAlsoReg = /. may (also )?refer to\b/i;

// templates that signal page is not a disambiguation
const notDisambig = {
  about: true,
  for: true,
  'for multi': true,
  'other people': true,
  'other uses of': true,
  'distinguish': true
};

const inTitle = new RegExp('. \\((' + disambig_titles.join('|') + ')\\)$', 'i');
const i18n_templates = disambig_templates.reduce((h, str) => {
  h[str] = true;
  return h
}, {});

// look for '... may refer to'
const byText = function (s) {
  if (!s) {
    return false
  }
  let txt = s.text();
  if (txt !== null && txt[0]) {
    if (mayAlsoReg.test(txt) === true) {
      return true
    }
  }
  return false
};

/**
 * Parses the wikitext to find out if this page is a disambiguation
 *
 * @private
 * @param {object} doc the document that is examined
 * @returns {boolean} an indication if the document is a disambiguation page
 */
const isDisambig = function (doc) {
  // check for a {{disambig}} template
  let templates = doc.templates().map((tmpl) => tmpl.json());
  let found = templates.find((obj) => {
    return templates$d.hasOwnProperty(obj.template) || i18n_templates.hasOwnProperty(obj.template)
  });
  if (found) {
    return true
  }
  // check for (disambiguation) in title
  let title = doc.title();
  if (title && inTitle.test(title) === true) {
    return true
  }
  // does it have a non-disambig template?
  let notDisamb = templates.find((obj) => notDisambig.hasOwnProperty(obj.template));
  if (notDisamb) {
    return false
  }
  //try 'may refer to' on first line for en-wiki?
  if (byText(doc.sentence(0)) === true || byText(doc.sentence(1)) === true) {
    return true
  }
  return false
};

let allStubs = new Set(stubs);

const isStub = function (doc) {
  // check for a {{disambig}} template
  let templates = doc.templates().map((tmpl) => tmpl.json());

  return templates.some((t) => {
    let name = t.template || '';
    // try i18n templates like 'stubo'
    if (allStubs.has(name)) {
      // console.log(name)
      return true
    }
    // english forms
    if (name === 'stub' || name.endsWith('-stub')) {
      // console.log(name)
      return true
    }
    // look for i18n in last-word, like {{foo-stubo}}
    let words = name.split(/[- ]/);
    if (words.length > 1) {
      let word = words[words.length - 1];
      if (allStubs.has(word)) {
        // console.log(name)
        return true
      }
    }
    return false
  })
};

const defaults$a = {
  caption: true,
  alt: true,
  links: true,
  thumb: true,
  url: true,
};
//
const toJson$3 = function (img, options) {
  options = setDefaults(options, defaults$a);
  let json = {
    file: img.file(),
  };
  if (options.thumb !== false) {
    json.thumb = img.thumbnail();
  }
  if (options.url !== false) {
    json.url = img.url();
  }
  //add captions
  if (options.caption !== false && img.data.caption) {
    json.caption = img.caption();
    if (options.links !== false && img.data.caption.links()) {
      json.links = img.links();
    }
  }
  if (options.alt !== false && img.data.alt) {
    json.alt = img.alt();
  }
  return json
};

const server = 'wikipedia.org';

const encodeTitle = function (file) {
  let title = file.replace(/^(image|file?):/i, '');
  //titlecase it
  title = title.charAt(0).toUpperCase() + title.substring(1);
  //spaces to underscores
  title = title.trim().replace(/ /g, '_');
  return title
};

//the wikimedia image url is a little silly:
const makeSrc = function (file) {
  let title = encodeTitle(file);
  title = encodeURIComponent(title);
  return title
};

//the class for our image generation functions
const Image = function (data) {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
};

const methods$8 = {
  file() {
    let file = this.data.file || '';
    if (file) {
      const regFile = /^(image|file):/i;
      if (!regFile.test(file)) {// if there's no 'File:', add it
        file = `File:${file}`;
      }
      file = file.trim();
      //titlecase it
      file = file.charAt(0).toUpperCase() + file.substring(1);
      //spaces to underscores
      file = file.replace(/ /g, '_');
    }
    return file
  },
  alt() {
    let str = this.data.alt || this.data.file || '';
    str = str.replace(/^(file|image):/i, '');
    str = str.replace(/\.(jpg|jpeg|png|gif|svg)/i, '');
    return str.replace(/_/g, ' ')
  },
  caption() {
    if (this.data.caption) {
      return this.data.caption.text()
    }
    return ''
  },
  links() {
    if (this.data.caption) {
      return this.data.caption.links()
    }
    return []
  },
  url() {
    // let lang = 'en' //this.language() || 'en' //hmm: get actual language?
    let fileName = makeSrc(this.file());
    let domain = this.data.domain || server;
    let path = `wiki/Special:Redirect/file`;
    return `https://${domain}/${path}/${fileName}`
  },
  thumbnail(size) {
    size = size || 300;
    return this.url() + '?width=' + size
  },
  format() {
    let arr = this.file().split('.');
    if (arr[arr.length - 1]) {
      return arr[arr.length - 1].toLowerCase()
    }
    return null
  },
  json: function (options) {
    options = options || {};
    return toJson$3(this, options)
  },
  text: function () {
    return ''
  },
  wikitext: function () {
    return this.data.wiki || ''
  },
};

Object.keys(methods$8).forEach((k) => {
  Image.prototype[k] = methods$8[k];
});

Image.prototype.src = Image.prototype.url;
Image.prototype.thumb = Image.prototype.thumbnail;

var languages = {
  aa: 'Afar', //Afar
  ab: 'Аҧсуа', //Abkhazian
  af: 'Afrikaans', //Afrikaans
  ak: 'Akana', //Akan
  als: 'Alemannisch', //Alemannic
  am: 'አማርኛ', //Amharic
  an: 'Aragonés', //Aragonese
  ang: 'Englisc', //Anglo-Saxon
  ar: 'العربية', //Arabic
  arc: 'ܣܘܪܬ', //Aramaic
  as: 'অসমীয়া', //Assamese
  ast: 'Asturianu', //Asturian
  av: 'Авар', //Avar
  ay: 'Aymar', //Aymara
  az: 'Azərbaycanca', //Azerbaijani
  ba: 'Башҡорт', //Bashkir
  bar: 'Boarisch', //Bavarian
  'bat-smg': 'Žemaitėška', //Samogitian
  bcl: 'Bikol', //Bikol
  be: 'Беларуская', //Belarusian
  'be-x-old': 'ltr', //Belarusian
  bg: 'Български', //Bulgarian
  bh: 'भोजपुरी', //Bihari
  bi: 'Bislama', //Bislama
  bm: 'Bamanankan', //Bambara
  bn: 'বাংলা', //Bengali
  bo: 'བོད་ཡིག', //Tibetan
  bpy: 'ltr', //Bishnupriya
  br: 'Brezhoneg', //Breton
  bs: 'Bosanski', //Bosnian
  bug: 'ᨅᨔ', //Buginese
  bxr: 'ltr', //Buriat
  ca: 'Català', //Catalan
  cdo: 'Chinese', //Min
  ce: 'Нохчийн', //Chechen
  ceb: 'Sinugboanong', //Cebuano
  ch: 'Chamoru', //Chamorro
  cho: 'Choctaw', //Choctaw
  chr: 'ᏣᎳᎩ', //Cherokee
  chy: 'Tsetsêhestâhese', //Cheyenne
  co: 'Corsu', //Corsican
  cr: 'Nehiyaw', //Cree
  cs: 'Česky', //Czech
  csb: 'Kaszëbsczi', //Kashubian
  cu: 'Slavonic', //Old
  cv: 'Чăваш', //Chuvash
  cy: 'Cymraeg', //Welsh
  da: 'Dansk', //Danish
  de: 'Deutsch', //German
  diq: 'Zazaki', //Dimli
  dsb: 'ltr', //Lower
  dv: 'ދިވެހިބަސް', //Divehi
  dz: 'ཇོང་ཁ', //Dzongkha
  ee: 'Ɛʋɛ', //Ewe
  far: 'فارسی', //Farsi
  el: 'Ελληνικά', //Greek
  en: 'English', //English
  eo: 'Esperanto', //Esperanto
  es: 'Español', //Spanish
  et: 'Eesti', //Estonian
  eu: 'Euskara', //Basque
  ext: 'Estremeñu', //Extremaduran
  ff: 'Fulfulde', //Peul
  fi: 'Suomi', //Finnish
  'fiu-vro': 'Võro', //Võro
  fj: 'Na', //Fijian
  fo: 'Føroyskt', //Faroese
  fr: 'Français', //French
  frp: 'Arpitan', //Arpitan
  fur: 'Furlan', //Friulian
  fy: 'ltr', //West
  ga: 'Gaeilge', //Irish
  gan: 'ltr', //Gan
  gd: 'ltr', //Scottish
  gil: 'Taetae', //Gilbertese
  gl: 'Galego', //Galician
  gn: "Avañe'ẽ", //Guarani
  got: 'gutisk', //Gothic
  gu: 'ગુજરાતી', //Gujarati
  gv: 'Gaelg', //Manx
  ha: 'هَوُسَ', //Hausa
  hak: 'ltr', //Hakka
  haw: 'Hawai`i', //Hawaiian
  he: 'עברית', //Hebrew
  hi: 'हिन्दी', //Hindi
  ho: 'ltr', //Hiri
  hr: 'Hrvatski', //Croatian
  ht: 'Krèyol', //Haitian
  hu: 'Magyar', //Hungarian
  hy: 'Հայերեն', //Armenian
  hz: 'Otsiherero', //Herero
  ia: 'Interlingua', //Interlingua
  id: 'Bahasa', //Indonesian
  ie: 'Interlingue', //Interlingue
  ig: 'Igbo', //Igbo
  ii: 'ltr', //Sichuan
  ik: 'Iñupiak', //Inupiak
  ilo: 'Ilokano', //Ilokano
  io: 'Ido', //Ido
  is: 'Íslenska', //Icelandic
  it: 'Italiano', //Italian
  iu: 'ᐃᓄᒃᑎᑐᑦ', //Inuktitut
  ja: '日本語', //Japanese
  jbo: 'Lojban', //Lojban
  jv: 'Basa', //Javanese
  ka: 'ქართული', //Georgian
  kg: 'KiKongo', //Kongo
  ki: 'Gĩkũyũ', //Kikuyu
  kj: 'Kuanyama', //Kuanyama
  kk: 'Қазақша', //Kazakh
  kl: 'Kalaallisut', //Greenlandic
  km: 'ភាសាខ្មែរ', //Cambodian
  kn: 'ಕನ್ನಡ', //Kannada
  khw: 'کھوار', //Khowar
  ko: '한국어', //Korean
  kr: 'Kanuri', //Kanuri
  ks: 'कश्मीरी', //Kashmiri
  ksh: 'Ripoarisch', //Ripuarian
  ku: 'Kurdî', //Kurdish
  kv: 'Коми', //Komi
  kw: 'Kernewek', //Cornish
  ky: 'Kırgızca', //Kirghiz
  la: 'Latina', //Latin
  lad: 'Dzhudezmo', //Ladino
  lan: 'Leb', //Lango
  lb: 'Lëtzebuergesch', //Luxembourgish
  lg: 'Luganda', //Ganda
  li: 'Limburgs', //Limburgian
  lij: 'Líguru', //Ligurian
  lmo: 'Lumbaart', //Lombard
  ln: 'Lingála', //Lingala
  lo: 'ລາວ', //Laotian
  lt: 'Lietuvių', //Lithuanian
  lv: 'Latviešu', //Latvian
  'map-bms': 'Basa', //Banyumasan
  mg: 'Malagasy', //Malagasy
  man: '官話', //Mandarin
  mh: 'Kajin', //Marshallese
  mi: 'Māori', //Maori
  min: 'Minangkabau', //Minangkabau
  mk: 'Македонски', //Macedonian
  ml: 'മലയാളം', //Malayalam
  mn: 'Монгол', //Mongolian
  mo: 'Moldovenească', //Moldovan
  mr: 'मराठी', //Marathi
  ms: 'Bahasa', //Malay
  mt: 'bil-Malti', //Maltese
  mus: 'Muskogee', //Creek
  my: 'Myanmasa', //Burmese
  na: 'Dorerin', //Nauruan
  nah: 'Nahuatl', //Nahuatl
  nap: 'Nnapulitano', //Neapolitan
  nd: 'ltr', //North
  nds: 'Plattdüütsch', //Low German
  'nds-nl': 'Saxon', //Dutch
  ne: 'नेपाली', //Nepali
  new: 'नेपालभाषा', //Newar
  ng: 'Oshiwambo', //Ndonga
  nl: 'Nederlands', //Dutch
  nn: 'ltr', //Norwegian
  no: 'Norsk', //Norwegian
  nr: 'ltr', //South
  nso: 'ltr', //Northern
  nrm: 'Nouormand', //Norman
  nv: 'Diné', //Navajo
  ny: 'Chi-Chewa', //Chichewa
  oc: 'Occitan', //Occitan
  oj: 'ᐊᓂᔑᓈᐯᒧᐎᓐ', //Ojibwa
  om: 'Oromoo', //Oromo
  or: 'ଓଡ଼ିଆ', //Oriya
  os: 'Иронау', //Ossetian
  pa: 'ਪੰਜਾਬੀ', //Panjabi
  pag: 'Pangasinan', //Pangasinan
  pam: 'Kapampangan', //Kapampangan
  pap: 'Papiamentu', //Papiamentu
  pdc: 'ltr', //Pennsylvania
  pi: 'Pāli', //Pali
  pih: 'Norfuk', //Norfolk
  pl: 'Polski', //Polish
  pms: 'Piemontèis', //Piedmontese
  ps: 'پښتو', //Pashto
  pt: 'Português', //Portuguese
  qu: 'Runa', //Quechua
  rm: 'ltr', //Raeto
  rmy: 'Romani', //Romani
  rn: 'Kirundi', //Kirundi
  ro: 'Română', //Romanian
  'roa-rup': 'Armâneashti', //Aromanian
  ru: 'Русский', //Russian
  rw: 'Kinyarwandi', //Rwandi
  sa: 'संस्कृतम्', //Sanskrit
  sc: 'Sardu', //Sardinian
  scn: 'Sicilianu', //Sicilian
  sco: 'Scots', //Scots
  sd: 'सिनधि', //Sindhi
  se: 'ltr', //Northern
  sg: 'Sängö', //Sango
  sh: 'Srpskohrvatski', //Serbo-Croatian
  si: 'සිංහල', //Sinhalese
  simple: 'ltr', //Simple
  sk: 'Slovenčina', //Slovak
  sl: 'Slovenščina', //Slovenian
  sm: 'Gagana', //Samoan
  sn: 'chiShona', //Shona
  so: 'Soomaaliga', //Somalia
  sq: 'Shqip', //Albanian
  sr: 'Српски', //Serbian
  ss: 'SiSwati', //Swati
  st: 'ltr', //Southern
  su: 'Basa', //Sundanese
  sv: 'Svenska', //Swedish
  sw: 'Kiswahili', //Swahili
  ta: 'தமிழ்', //Tamil
  te: 'తెలుగు', //Telugu
  tet: 'Tetun', //Tetum
  tg: 'Тоҷикӣ', //Tajik
  th: 'ไทย', //Thai
  ti: 'ትግርኛ', //Tigrinya
  tk: 'Туркмен', //Turkmen
  tl: 'Tagalog', //Tagalog
  tlh: 'tlhIngan-Hol', //Klingon
  tn: 'Setswana', //Tswana
  to: 'Lea', //Tonga
  tpi: 'ltr', //Tok
  tr: 'Türkçe', //Turkish
  ts: 'Xitsonga', //Tsonga
  tt: 'Tatarça', //Tatar
  tum: 'chiTumbuka', //Tumbuka
  tw: 'Twi', //Twi
  ty: 'Reo', //Tahitian
  udm: 'Удмурт', //Udmurt
  ug: 'Uyƣurqə', //Uyghur
  uk: 'Українська', //Ukrainian
  ur: 'اردو', //Urdu
  uz: 'Ўзбек', //Uzbek
  ve: 'Tshivenḓa', //Venda
  vi: 'Việtnam', //Vietnamese
  vec: 'Vèneto', //Venetian
  vls: 'ltr', //West
  vo: 'Volapük', //Volapük
  wa: 'Walon', //Walloon
  war: 'Winaray', //Waray-Waray
  wo: 'Wollof', //Wolof
  xal: 'Хальмг', //Kalmyk
  xh: 'isiXhosa', //Xhosa
  yi: 'ייִדיש', //Yiddish
  yo: 'Yorùbá', //Yoruba
  za: 'Cuengh', //Zhuang
  zh: '中文', //Chinese
  'zh-classical': 'ltr', //Classical
  'zh-min-nan': 'Bân-lâm-gú', //Minnan
  'zh-yue': '粵語', //Cantonese
  zu: 'isiZulu', //Zulu
};

const wp = '.wikipedia.org/wiki/$1';
const wm = '.wikimedia.org/wiki/$1';
const w = 'www.';

var wikis = {
  acronym: w + 'acronymfinder.com/$1.html',
  advisory: 'advisory' + wm,
  advogato: w + 'advogato.org/$1',
  aew: 'wiki.arabeyes.org/$1',
  appropedia: w + 'appropedia.org/$1',
  aquariumwiki: w + 'theaquariumwiki.com/$1',
  arborwiki: 'localwiki.org/ann-arbor/$1',
  arxiv: 'arxiv.org/abs/$1',
  atmwiki: w + 'otterstedt.de/wiki/index.php/$1',
  baden: w + 'stadtwiki-baden-baden.de/wiki/$1/',
  battlestarwiki: 'en.battlestarwiki.org/wiki/$1',
  bcnbio: 'historiapolitica.bcn.cl/resenas_parlamentarias/wiki/$1',
  beacha: w + 'beachapedia.org/$1',
  betawiki: 'translatewiki.net/wiki/$1',
  bibcode: 'adsabs.harvard.edu/abs/$1',
  bibliowiki: 'wikilivres.org/wiki/$1',
  bluwiki: 'bluwiki.com/go/$1',
  blw: 'britainloves' + wp,
  botwiki: 'botwiki.sno.cc/wiki/$1',
  boxrec: w + 'boxrec.com/media/index.php?$1',
  brickwiki: w + 'brickwiki.info/wiki/$1',
  bugzilla: 'bugzilla.wikimedia.org/show_bug.cgi?id=$1',
  bulba: 'bulbapedia.bulbagarden.net/wiki/$1',
  c: 'commons' + wm,
  c2: 'c2.com/cgi/wiki?$1',
  c2find: 'c2.com/cgi/wiki?FindPage&value=$1',
  cache: w + 'google.com/search?q=cache:$1',
  ĉej: 'esperanto.blahus.cz/cxej/vikio/index.php/$1',
  cellwiki: 'cell.wikia.com/wiki/$1',
  centralwikia: 'community.wikia.com/wiki/$1',
  chej: 'esperanto.blahus.cz/cxej/vikio/index.php/$1',
  choralwiki: w + 'cpdl.org/wiki/index.php/$1',
  citizendium: 'en.citizendium.org/wiki/$1',
  ckwiss: w + 'ck-wissen.de/ckwiki/index.php?title=$1',
  comixpedia: w + 'comixpedia.org/index.php?title=$1',
  commons: 'commons' + wm,
  communityscheme: 'community.schemewiki.org/?c=s&key=$1',
  communitywiki: 'communitywiki.org/$1',
  comune: 'rete.comuni-italiani.it/wiki/$1',
  creativecommons: 'creativecommons.org/licenses/$1',
  creativecommonswiki: 'wiki.creativecommons.org/$1',
  cxej: 'esperanto.blahus.cz/cxej/vikio/index.php/$1',
  dcc: w + 'dccwiki.com/$1',
  dcdatabase: 'dc.wikia.com/$1',
  dcma: 'christian-morgenstern.de/dcma/index.php?title=$1',
  debian: 'wiki.debian.org/$1',
  delicious: w + 'delicious.com/tag/$1',
  devmo: 'developer.mozilla.org/en/docs/$1',
  dictionary: w + 'dict.org/bin/Dict?Database=*&Form=Dict1&Strategy=*&Query=$1',
  dict: w + 'dict.org/bin/Dict?Database=*&Form=Dict1&Strategy=*&Query=$1',
  disinfopedia: 'sourcewatch.org/index.php/$1',
  distributedproofreaders: w + 'pgdp.net/wiki/$1',
  distributedproofreadersca: w + 'pgdpcanada.net/wiki/index.php/$1',
  dmoz: 'curlie.org/$1',
  dmozs: 'curlie.org/search?q=$1',
  doi: 'doi.org/$1',
  donate: 'donate' + wm,
  doom_wiki: 'doom.wikia.com/wiki/$1',
  download: 'releases.wikimedia.org/$1',
  dbdump: 'dumps.wikimedia.org/$1/latest/',
  dpd: 'lema.rae.es/dpd/?key=$1',
  drae: 'dle.rae.es/?w=$1',
  dreamhost: 'wiki.dreamhost.com/index.php/$1',
  drumcorpswiki: w + 'drumcorpswiki.com/index.php/$1',
  dwjwiki: w + 'suberic.net/cgi-bin/dwj/wiki.cgi?$1',
  eĉei: w + 'ikso.net/cgi-bin/wiki.pl?$1',
  ecoreality: w + 'EcoReality.org/wiki/$1',
  ecxei: w + 'ikso.net/cgi-bin/wiki.pl?$1',
  elibre: 'enciclopedia.us.es/index.php/$1',
  emacswiki: w + 'emacswiki.org/emacs?$1',
  encyc: 'encyc.org/wiki/$1',
  energiewiki: w + 'netzwerk-energieberater.de/wiki/index.php/$1',
  englyphwiki: 'en.glyphwiki.org/wiki/$1',
  enkol: 'enkol.pl/$1',
  eokulturcentro: 'esperanto.toulouse.free.fr/nova/wikini/wakka.php?wiki=$1',
  esolang: 'esolangs.org/wiki/$1',
  etherpad: 'etherpad.wikimedia.org/$1',
  ethnologue: w + 'ethnologue.com/language/$1',
  ethnologuefamily: w + 'ethnologue.com/show_family.asp?subid=$1',
  evowiki: 'wiki.cotch.net/index.php/$1',
  exotica: w + 'exotica.org.uk/wiki/$1',
  fanimutationwiki: 'wiki.animutationportal.com/index.php/$1',
  fedora: 'fedoraproject.org/wiki/$1',
  finalfantasy: 'finalfantasy.wikia.com/wiki/$1',
  finnix: w + 'finnix.org/$1',
  flickruser: w + 'flickr.com/people/$1',
  flickrphoto: w + 'flickr.com/photo.gne?id=$1',
  floralwiki: w + 'floralwiki.co.uk/wiki/$1',
  foldoc: 'foldoc.org/$1',
  foundation: 'foundation' + wm,
  foundationsite: 'wikimediafoundation.org/$1',
  foxwiki: 'fox.wikis.com/wc.dll?Wiki~$1',
  freebio: 'freebiology.org/wiki/$1',
  freebsdman: w + 'FreeBSD.org/cgi/man.cgi?apropos=1&query=$1',
  freeculturewiki: 'wiki.freeculture.org/index.php/$1',
  freedomdefined: 'freedomdefined.org/$1',
  freefeel: 'freefeel.org/wiki/$1',
  freekiwiki: 'wiki.freegeek.org/index.php/$1',
  // freenode: 'irc://irc.freenode.net/$1',
  freesoft: 'directory.fsf.org/wiki/$1',
  ganfyd: 'ganfyd.org/index.php?title=$1',
  gardenology: w + 'gardenology.org/wiki/$1',
  gausswiki: 'gauss.ffii.org/$1',
  gentoo: 'wiki.gentoo.org/wiki/$1',
  genwiki: 'wiki.genealogy.net/index.php/$1',
  gerrit: 'gerrit.wikimedia.org/r/$1',
  git: 'gerrit.wikimedia.org/g/$1',
  google: w + 'google.com/search?q=$1',
  googledefine: w + 'google.com/search?q=define:$1',
  googlegroups: 'groups.google.com/groups?q=$1',
  guildwarswiki: 'wiki.guildwars.com/wiki/$1',
  guildwiki: 'guildwars.wikia.com/wiki/$1',
  guc: 'tools.wmflabs.org/guc/?user=$1',
  gucprefix: 'tools.wmflabs.org/guc/?isPrefixPattern=1&src=rc&user=$1',
  gutenberg: w + 'gutenberg.org/etext/$1',
  gutenbergwiki: w + 'gutenberg.org/wiki/$1',
  hackerspaces: 'hackerspaces.org/wiki/$1',
  h2wiki: 'halowiki.net/p/$1',
  hammondwiki: w + 'dairiki.org/HammondWiki/index.php3?$1',
  hdl: 'hdl.handle.net/$1',
  heraldik: 'heraldik-wiki.de/wiki/$1',
  heroeswiki: 'heroeswiki.com/$1',
  horizonlabs: 'horizon.wikimedia.org/$1',
  hrwiki: w + 'hrwiki.org/index.php/$1',
  hrfwiki: 'fanstuff.hrwiki.org/index.php/$1',
  hupwiki: 'wiki.hup.hu/index.php/$1',
  iarchive: 'archive.org/details/$1',
  imdbname: w + 'imdb.com/name/nm$1/',
  imdbtitle: w + 'imdb.com/title/tt$1/',
  imdbcompany: w + 'imdb.com/company/co$1/',
  imdbcharacter: w + 'imdb.com/character/ch$1/',
  incubator: 'incubator' + wm,
  infosecpedia: 'infosecpedia.org/wiki/$1',
  infosphere: 'theinfosphere.org/$1',
  // irc: 'irc://irc.freenode.net/$1',
  // ircs: 'ircs://irc.freenode.net/$1',
  // ircrc: 'irc://irc.wikimedia.org/$1',
  // rcirc: 'irc://irc.wikimedia.org/$1',
  'iso639-3': 'iso639-3.sil.org/code/$1',
  issn: w + 'worldcat.org/issn/$1',
  iuridictum: 'iuridictum.pecina.cz/w/$1',
  jaglyphwiki: 'glyphwiki.org/wiki/$1',
  jefo: 'esperanto-jeunes.org/wiki/$1',
  jerseydatabase: 'jerseydatabase.com/wiki.php?id=$1',
  jira: 'jira.toolserver.org/browse/$1',
  jspwiki: w + 'ecyrd.com/JSPWiki/Wiki.jsp?page=$1',
  jstor: w + 'jstor.org/journals/$1',
  kamelo: 'kamelopedia.mormo.org/index.php/$1',
  karlsruhe: 'ka.stadtwiki.net/$1',
  kinowiki: 'kino.skripov.com/index.php/$1',
  komicawiki: 'wiki.komica.org/?$1',
  kontuwiki: 'kontu.wiki/$1',
  wikitech: 'wikitech' + wm,
  libreplanet: 'libreplanet.org/wiki/$1',
  linguistlist: 'linguistlist.org/forms/langs/LLDescription.cfm?code=$1',
  linuxwiki: w + 'linuxwiki.de/$1',
  linuxwikide: w + 'linuxwiki.de/$1',
  liswiki: 'liswiki.org/wiki/$1',
  literateprograms: 'en.literateprograms.org/$1',
  livepedia: w + 'livepedia.gr/index.php?title=$1',
  localwiki: 'localwiki.org/$1',
  lojban: 'mw.lojban.org/papri/$1',
  lostpedia: 'lostpedia.wikia.com/wiki/$1',
  lqwiki: 'wiki.linuxquestions.org/wiki/$1',
  luxo: 'tools.wmflabs.org/guc/?user=$1',
  mail: 'lists.wikimedia.org/mailman/listinfo/$1',
  mailarchive: 'lists.wikimedia.org/pipermail/$1',
  mariowiki: w + 'mariowiki.com/$1',
  marveldatabase: w + 'marveldatabase.com/wiki/index.php/$1',
  meatball: 'meatballwiki.org/wiki/$1',
  mw: w + 'mediawiki.org/wiki/$1',
  mediazilla: 'bugzilla.wikimedia.org/$1',
  memoryalpha: 'memory-alpha.fandom.com/wiki/$1',
  metawiki: 'meta' + wm,
  metawikimedia: 'meta' + wm,
  metawikipedia: 'meta' + wm,
  mineralienatlas: w + 'mineralienatlas.de/lexikon/index.php/$1',
  moinmoin: 'moinmo.in/$1',
  monstropedia: w + 'monstropedia.org/?title=$1',
  mosapedia: 'mosapedia.de/wiki/index.php/$1',
  mozcom: 'mozilla.wikia.com/wiki/$1',
  mozillawiki: 'wiki.mozilla.org/$1',
  mozillazinekb: 'kb.mozillazine.org/$1',
  musicbrainz: 'musicbrainz.org/doc/$1',
  mediawikiwiki: w + 'mediawiki.org/wiki/$1',
  mwod: w + 'merriam-webster.com/dictionary/$1',
  mwot: w + 'merriam-webster.com/thesaurus/$1',
  nkcells: w + 'nkcells.info/index.php?title=$1',
  nara: 'catalog.archives.gov/id/$1',
  nosmoke: 'no-smok.net/nsmk/$1',
  nost: 'nostalgia' + wp,
  nostalgia: 'nostalgia' + wp,
  oeis: 'oeis.org/$1',
  oldwikisource: 'wikisource.org/wiki/$1',
  olpc: 'wiki.laptop.org/go/$1',
  omegawiki: w + 'omegawiki.org/Expression:$1',
  onelook: w + 'onelook.com/?ls=b&w=$1',
  openlibrary: 'openlibrary.org/$1',
  openstreetmap: 'wiki.openstreetmap.org/wiki/$1',
  openwetware: 'openwetware.org/wiki/$1',
  opera7wiki: 'operawiki.info/$1',
  organicdesign: w + 'organicdesign.co.nz/$1',
  orthodoxwiki: 'orthodoxwiki.org/$1',
  osmwiki: 'wiki.openstreetmap.org/wiki/$1',
  otrs: 'ticket.wikimedia.org/otrs/index.pl?Action=AgentTicketZoom&TicketID=$1',
  otrswiki: 'otrs-wiki' + wm,
  ourmedia: w + 'socialtext.net/ourmedia/index.cgi?$1',
  outreach: 'outreach' + wm,
  outreachwiki: 'outreach' + wm,
  owasp: w + 'owasp.org/index.php/$1',
  panawiki: 'wiki.alairelibre.net/index.php?title=$1',
  patwiki: 'gauss.ffii.org/$1',
  personaltelco: 'personaltelco.net/wiki/$1',
  petscan: 'petscan.wmflabs.org/?psid=$1',
  phab: 'phabricator.wikimedia.org/$1',
  phabricator: 'phabricator.wikimedia.org/$1',
  phwiki: w + 'pocketheaven.com/ph/wiki/index.php?title=$1',
  phpwiki: 'phpwiki.sourceforge.net/phpwiki/index.php?$1',
  planetmath: 'planetmath.org/node/$1',
  pmeg: w + 'bertilow.com/pmeg/$1',
  pmid: w + 'ncbi.nlm.nih.gov/pubmed/$1?dopt=Abstract',
  pokewiki: 'pokewiki.de/$1',
  pokéwiki: 'pokewiki.de/$1',
  policy: 'policy.wikimedia.org/$1',
  proofwiki: w + 'proofwiki.org/wiki/$1',
  pyrev: w + 'mediawiki.org/wiki/Special:Code/pywikipedia/$1',
  pythoninfo: 'wiki.python.org/moin/$1',
  pythonwiki: w + 'pythonwiki.de/$1',
  pywiki: 'c2.com/cgi/wiki?$1',
  psycle: 'psycle.sourceforge.net/wiki/$1',
  quality: 'quality' + wm,
  quarry: 'quarry.wmflabs.org/$1',
  regiowiki: 'regiowiki.at/wiki/$1',
  rev: w + 'mediawiki.org/wiki/Special:Code/MediaWiki/$1',
  revo: 'purl.org/NET/voko/revo/art/$1.html',
  rfc: 'tools.ietf.org/html/rfc$1',
  rheinneckar: 'rhein-neckar-wiki.de/$1',
  robowiki: 'robowiki.net/?$1',
  rodovid: 'en.rodovid.org/wk/$1',
  reuterswiki: 'glossary.reuters.com/index.php/$1',
  rowiki: 'wiki.rennkuckuck.de/index.php/$1',
  rt: 'rt.wikimedia.org/Ticket/Display.html?id=$1',
  // rtfm: 'ftp://rtfm.mit.edu/pub/faqs/$1',
  s23wiki: 's23.org/wiki/$1',
  scholar: 'scholar.google.com/scholar?q=$1',
  schoolswp: 'schools-' + wp,
  scores: 'imslp.org/wiki/$1',
  scoutwiki: 'en.scoutwiki.org/$1',
  scramble: w + 'scramble.nl/wiki/index.php?title=$1',
  seapig: w + 'seapig.org/$1',
  seattlewiki: 'seattle.wikia.com/wiki/$1',
  slwiki: 'wiki.secondlife.com/wiki/$1',
  'semantic-mw': w + 'semantic-mediawiki.org/wiki/$1',
  senseislibrary: 'senseis.xmp.net/?$1',
  sharemap: 'sharemap.org/$1',
  silcode: w + 'sil.org/iso639-3/documentation.asp?id=$1',
  slashdot: 'slashdot.org/article.pl?sid=$1',
  sourceforge: 'sourceforge.net/$1',
  spcom: 'spcom' + wm,
  species: 'species' + wm,
  squeak: 'wiki.squeak.org/squeak/$1',
  stats: 'stats.wikimedia.org/$1',
  stewardry: 'tools.wmflabs.org/meta/stewardry/?wiki=$1',
  strategy: 'strategy' + wm,
  strategywiki: 'strategywiki.org/wiki/$1',
  sulutil: 'meta.wikimedia.org/wiki/Special:CentralAuth/$1',
  swtrain: 'train.spottingworld.com/$1',
  svn: 'svn.wikimedia.org/viewvc/mediawiki/$1?view=log',
  swinbrain: 'swinbrain.ict.swin.edu.au/wiki/$1',
  tabwiki: w + 'tabwiki.com/index.php/$1',
  tclerswiki: 'wiki.tcl.tk/$1',
  technorati: w + 'technorati.com/search/$1',
  tenwiki: 'ten' + wp,
  testwiki: 'test' + wp,
  testwikidata: 'test.wikidata.org/wiki/$1',
  test2wiki: 'test2' + wp,
  tfwiki: 'tfwiki.net/wiki/$1',
  thelemapedia: w + 'thelemapedia.org/index.php/$1',
  theopedia: w + 'theopedia.com/$1',
  thinkwiki: w + 'thinkwiki.org/wiki/$1',
  ticket: 'ticket.wikimedia.org/otrs/index.pl?Action=AgentTicketZoom&TicketNumber=$1',
  tmbw: 'tmbw.net/wiki/$1',
  tmnet: w + 'technomanifestos.net/?$1',
  tmwiki: w + 'EasyTopicMaps.com/?page=$1',
  toolforge: 'tools.wmflabs.org/$1',
  toollabs: 'tools.wmflabs.org/$1',
  tools: 'toolserver.org/$1',
  tswiki: w + 'mediawiki.org/wiki/Toolserver:$1',
  translatewiki: 'translatewiki.net/wiki/$1',
  tviv: 'tviv.org/wiki/$1',
  tvtropes: w + 'tvtropes.org/pmwiki/pmwiki.php/Main/$1',
  twiki: 'twiki.org/cgi-bin/view/$1',
  tyvawiki: w + 'tyvawiki.org/wiki/$1',
  umap: 'umap.openstreetmap.fr/$1',
  uncyclopedia: 'en.uncyclopedia.co/wiki/$1',
  unihan: w + 'unicode.org/cgi-bin/GetUnihanData.pl?codepoint=$1',
  unreal: 'wiki.beyondunreal.com/wiki/$1',
  urbandict: w + 'urbandictionary.com/define.php?term=$1',
  usej: w + 'tejo.org/usej/$1',
  usemod: w + 'usemod.com/cgi-bin/wiki.pl?$1',
  usability: 'usability' + wm,
  utrs: 'utrs.wmflabs.org/appeal.php?id=$1',
  vikidia: 'fr.vikidia.org/wiki/$1',
  vlos: 'tusach.thuvienkhoahoc.com/wiki/$1',
  vkol: 'kol.coldfront.net/thekolwiki/index.php/$1',
  voipinfo: w + 'voip-info.org/wiki/view/$1',
  votewiki: 'vote' + wm,
  werelate: w + 'werelate.org/wiki/$1',
  wg: 'wg-en' + wp,
  wikia: w + 'wikia.com/wiki/w:c:$1',
  wikiasite: w + 'wikia.com/wiki/w:c:$1',
  wikiapiary: 'wikiapiary.com/wiki/$1',
  wikibooks: 'en.wikibooks.org/wiki/$1',
  wikichristian: w + 'wikichristian.org/index.php?title=$1',
  wikicities: w + 'wikia.com/wiki/w:$1',
  wikicity: w + 'wikia.com/wiki/w:c:$1',
  wikiconference: 'wikiconference.org/wiki/$1',
  wikidata: w + 'wikidata.org/wiki/$1',
  wikif1: w + 'wikif1.org/$1',
  wikifur: 'en.wikifur.com/wiki/$1',
  wikihow: w + 'wikihow.com/$1',
  wikiindex: 'wikiindex.org/$1',
  wikilemon: 'wiki.illemonati.com/$1',
  wikilivres: 'wikilivres.org/wiki/$1',
  wikilivresru: 'wikilivres.ru/$1',
  'wikimac-de': 'apfelwiki.de/wiki/Main/$1',
  wikimedia: 'foundation' + wm,
  wikinews: 'en.wikinews.org/wiki/$1',
  wikinfo: 'wikinfo.org/w/index.php/$1',
  wikinvest: 'meta.wikimedia.org/wiki/Interwiki_map/discontinued#Wikinvest',
  wikiotics: 'wikiotics.org/$1',
  wikipapers: 'wikipapers.referata.com/wiki/$1',
  wikipedia: 'en' + wp,
  wikipediawikipedia: 'en.wikipedia.org/wiki/Wikipedia:$1',
  wikiquote: 'en.wikiquote.org/wiki/$1',
  wikisophia: 'wikisophia.org/index.php?title=$1',
  wikisource: 'en.wikisource.org/wiki/$1',
  wikispecies: 'species' + wm,
  wikispot: 'wikispot.org/?action=gotowikipage&v=$1',
  wikiskripta: w + 'wikiskripta.eu/index.php/$1',
  labsconsole: 'wikitech' + wm,
  wikiti: 'wikiti.denglend.net/index.php?title=$1',
  wikiversity: 'en.wikiversity.org/wiki/$1',
  wikivoyage: 'en.wikivoyage.org/wiki/$1',
  betawikiversity: 'beta.wikiversity.org/wiki/$1',
  wikiwikiweb: 'c2.com/cgi/wiki?$1',
  wiktionary: 'en.wiktionary.org/wiki/$1',
  wipipedia: 'wipipedia.org/index.php/$1',
  wlug: w + 'wlug.org.nz/$1',
  wmam: 'am' + wm,
  wmar: w + 'wikimedia.org.ar/wiki/$1',
  wmat: 'mitglieder.wikimedia.at/$1',
  wmau: 'wikimedia.org.au/wiki/$1',
  wmbd: 'bd' + wm,
  wmbe: 'be' + wm,
  wmbr: 'br' + wm,
  wmca: 'ca' + wm,
  wmch: w + 'wikimedia.ch/$1',
  wmcl: w + 'wikimediachile.cl/index.php?title=$1',
  wmcn: 'cn' + wm,
  wmco: 'co' + wm,
  wmcz: w + 'wikimedia.cz/web/$1',
  wmdc: 'wikimediadc.org/wiki/$1',
  securewikidc: 'secure.wikidc.org/$1',
  wmde: 'wikimedia.de/wiki/$1',
  wmdk: 'dk' + wm,
  wmee: 'ee' + wm,
  wmec: 'ec' + wm,
  wmes: w + 'wikimedia.es/wiki/$1',
  wmet: 'ee' + wm,
  wmfdashboard: 'outreachdashboard.wmflabs.org/$1',
  wmfi: 'fi' + wm,
  wmfr: 'wikimedia.fr/$1',
  wmge: 'ge' + wm,
  wmhi: 'hi' + wm,
  wmhk: 'meta.wikimedia.org/wiki/Wikimedia_Hong_Kong',
  wmhu: 'wikimedia.hu/wiki/$1',
  wmid: 'id' + wm,
  wmil: w + 'wikimedia.org.il/$1',
  wmin: 'wiki.wikimedia.in/$1',
  wmit: 'wiki.wikimedia.it/wiki/$1',
  wmke: 'meta.wikimedia.org/wiki/Wikimedia_Kenya',
  wmmk: 'mk' + wm,
  wmmx: 'mx' + wm,
  wmnl: 'nl' + wm,
  wmnyc: 'nyc' + wm,
  wmno: 'no' + wm,
  'wmpa-us': 'pa-us' + wm,
  wmph: 'meta.wikimedia.org/wiki/Wikimedia_Philippines',
  wmpl: 'pl' + wm,
  wmpt: 'pt' + wm,
  wmpunjabi: 'punjabi' + wm,
  wmromd: 'romd' + wm,
  wmrs: 'rs' + wm,
  wmru: 'ru' + wm,
  wmse: 'se' + wm,
  wmsk: 'wikimedia.sk/$1',
  wmtr: 'tr' + wm,
  wmtw: 'wikimedia.tw/wiki/index.php5/$1',
  wmua: 'ua' + wm,
  wmuk: 'wikimedia.org.uk/wiki/$1',
  wmve: 'wikimedia.org.ve/wiki/$1',
  wmza: 'wikimedia.org.za/wiki/$1',
  wm2005: 'wikimania2005' + wm,
  wm2006: 'wikimania2006' + wm,
  wm2007: 'wikimania2007' + wm,
  wm2008: 'wikimania2008' + wm,
  wm2009: 'wikimania2009' + wm,
  wm2010: 'wikimania2010' + wm,
  wm2011: 'wikimania2011' + wm,
  wm2012: 'wikimania2012' + wm,
  wm2013: 'wikimania2013' + wm,
  wm2014: 'wikimania2014' + wm,
  wm2015: 'wikimania2015' + wm,
  wm2016: 'wikimania2016' + wm,
  wm2017: 'wikimania2017' + wm,
  wm2018: 'wikimania2018' + wm,
  wmania: 'wikimania' + wm,
  wikimania: 'wikimania' + wm,
  wmteam: 'wikimaniateam' + wm,
  wmf: 'foundation' + wm,
  wmfblog: 'blog.wikimedia.org/$1',
  wmdeblog: 'blog.wikimedia.de/$1',
  wookieepedia: 'starwars.wikia.com/wiki/$1',
  wowwiki: w + 'wowwiki.com/$1',
  wqy: 'wqy.sourceforge.net/cgi-bin/index.cgi?$1',
  wurmpedia: 'wurmpedia.com/index.php/$1',
  viaf: 'viaf.org/viaf/$1',
  zrhwiki: w + 'zrhwiki.ch/wiki/$1',
  zum: 'wiki.zum.de/$1',
  zwiki: w + 'zwiki.org/$1',
  m: 'meta' + wm,
  meta: 'meta' + wm,
  sep11: 'sep11' + wp,
  d: w + 'wikidata.org/wiki/$1',
  minnan: 'zh-min-nan' + wp,
  nb: 'no' + wp,
  'zh-cfr': 'zh-min-nan' + wp,
  'zh-cn': 'zh' + wp,
  'zh-tw': 'zh' + wp,
  nan: 'zh-min-nan' + wp,
  vro: 'fiu-vro' + wp,
  cmn: 'zh' + wp,
  lzh: 'zh-classical' + wp,
  rup: 'roa-rup' + wp,
  gsw: 'als' + wp,
  'be-tarask': 'be-x-old' + wp,
  sgs: 'bat-smg' + wp,
  egl: 'eml' + wp,
  w: 'en' + wp,
  wikt: 'en.wiktionary.org/wiki/$1',
  q: 'en.wikiquote.org/wiki/$1',
  b: 'en.wikibooks.org/wiki/$1',
  n: 'en.wikinews.org/wiki/$1',
  s: 'en.wikisource.org/wiki/$1',
  chapter: 'en' + wm,
  v: 'en.wikiversity.org/wiki/$1',
  voy: 'en.wikivoyage.org/wiki/$1',
};

//add language prefixes too..
Object.keys(languages).forEach((k) => {
  wikis[k] = k + '.wikipedia.org/wiki/$1';
});

//this is predictably very complicated.
// https://meta.wikimedia.org/wiki/Help:Interwiki_linking
const parseInterwiki = function (obj) {
  let str = obj.page || '';
  if (str.indexOf(':') !== -1) {
    let m = str.match(/^(.*):(.*)/);
    if (m === null) {
      return obj
    }
    let site = m[1] || '';
    site = site.toLowerCase();
    // double colon - [[m:Help:Help]] 
    if (site.indexOf(':') !== -1) {
      let [, wiki, lang] = site.match(/^:?(.*):(.*)/);
      //only allow interwikis to these specific places
      if (wikis.hasOwnProperty(wiki) === false || languages.hasOwnProperty(lang) === false) {
        return obj
      }
      obj.wiki = { wiki: wiki, lang: lang };
    } else {
      // [[fr:cool]]
      if (wikis.hasOwnProperty(site) === false) {
        return obj
      }
      obj.wiki = site;
    }
    obj.page = m[2];
  }
  return obj
};

const ignore_links =
  /^(category|catégorie|kategorie|categoría|categoria|categorie|kategoria|تصنيف|image|file|fichier|datei|media):/i;
const external_link = /\[(https?|news|ftp|mailto|gopher|irc)(:\/\/[^\]| ]{4,1500})([| ].*?)?\]/g;
const link_reg = /\[\[(.{0,1600}?)\]\]([a-z]+)?/gi; //allow dangling suffixes - "[[flanders]]s"

const external_links = function (links, str) {
  str.replace(external_link, function (raw, protocol, link, text) {
    text = text || '';
    links.push({
      type: 'external',
      site: protocol + link,
      text: text.trim(),
      raw: raw,
    });
    return text
  });
  return links
};

const internal_links = function (links, str) {
  //regular links
  str.replace(link_reg, function (raw, s, suffix) {
    let txt = null;
    //make a copy of original
    let link = s;
    if (s.match(/\|/)) {
      //replacement link [[link|text]]
      s = s.replace(/\[\[(.{2,1000}?)\]\](\w{0,10})/g, '$1$2'); //remove ['s and keep suffix
      link = s.replace(/(.{2,1000})\|.{0,2000}/, '$1'); //replaced links
      txt = s.replace(/.{2,1000}?\|/, '');
      //handle funky case of [[toronto|]]
      if (txt === null && link.match(/\|$/)) {
        link = link.replace(/\|$/, '');
        txt = link;
      }
    }
    //kill off non-wikipedia namespaces
    if (link.match(ignore_links)) {
      return s
    }
    //kill off just these just-anchor links [[#history]]
    // if (link.match(/^#/i)) {
    //   console.log(s)
    //   return s
    // }
    //remove anchors from end [[toronto#history]]
    let obj = {
      page: link,
      raw: raw,
    };
    obj.page = obj.page.replace(/#(.*)/, (a, b) => {
      obj.anchor = b;
      return ''
    });
    //grab any fr:Paris parts
    obj = parseInterwiki(obj);
    if (obj.wiki) {
      obj.type = 'interwiki';
    }
    if (txt !== null && txt !== obj.page) {
      obj.text = txt;
    }
    //finally, support [[link]]'s apostrophe
    if (suffix) {
      obj.text = obj.text || obj.page;
      obj.text += suffix.trim();
    }
    //titlecase it, if necessary
    if (obj.page && /^[A-Z]/.test(obj.page) === false) {
      if (!obj.text) {
        obj.text = obj.page;
      }
      obj.page = obj.page;
    }
    // support [[:Category:Foo]] syntax
    if (obj.text && obj.text.startsWith(':')) {
      obj.text = obj.text.replace(/^:/, '');
    }
    links.push(obj);
    return s
  });
  return links
};

//grab an array of internal links in the text
const parse_links = function (str) {
  let links = [];
  //first, parse external links
  links = external_links(links, str);
  //internal links
  links = internal_links(links, str);
  if (links.length === 0) {
    return undefined
  }
  return links
};

//pulls target link out of redirect page
const REDIRECT_REGEX = new RegExp('^[ \n\t]*?#(' + redirects.join('|') + ') *?(\\[\\[.{2,180}?\\]\\])', 'i');

const isRedirect = function (wiki) {
  //too long to be a redirect?
  if (!wiki) {
    return false
  }
  return REDIRECT_REGEX.test(wiki)
};

const parse = function (wiki) {
  let m = wiki.match(REDIRECT_REGEX);
  if (m && m[2]) {
    let links = parse_links(m[2]) || [];
    return links[0]
  }
  return {}
};

//okay, i know you're not supposed to regex html, but...
//https://en.wikipedia.org/wiki/Help:HTML_in_wikitext

//these are things we throw-away
//these will mess-up if they're nested, but they're not usually.
const ignore$1 = [
  'table',
  'code',
  'score',
  'data',
  'categorytree',
  'charinsert',
  'hiero',
  'imagemap',
  'inputbox',
  'references',
  'source',
  'syntaxhighlight',
  'timeline',
  'maplink',
];
const openTag = `< ?(${ignore$1.join('|')}) ?[^>]{0,200}?>`;
const closeTag = `< ?/ ?(${ignore$1.join('|')}) ?>`;
const anyChar = '\\s\\S'; //including newline
const noThanks = new RegExp(`${openTag}[${anyChar}]+?${closeTag}`, 'gi');

const kill_xml = function (wiki) {
  //(<ref> tags are parsed in Section class) - luckily, refs can't be recursive.
  //types of html/xml that we want to trash completely.
  wiki = wiki.replace(noThanks, ' ');
  //some xml-like fragments we can also kill
  wiki = wiki.replace(/ ?< ?(span|div|table|data) [a-zA-Z0-9=%.\-#:;'" ]{2,100}\/? ?> ?/g, ' '); //<ref name="asd">
  //only kill ref tags if they are selfclosing
  wiki = wiki.replace(/ ?< ?(ref) [a-zA-Z0-9=" ]{2,100}\/ ?> ?/g, ' '); //<ref name="asd"/>

  // convert these html tags to known formatting
  wiki = wiki.replace(/<i>(.*?)<\/i>/g, `''$1''`);
  wiki = wiki.replace(/<b>(.*?)<\/b>/g, `'''$1'''`);

  // these are better-handled with templates
  wiki = wiki.replace(/<sub>(.*?)<\/sub>/g, `{{sub|$1}}`);
  wiki = wiki.replace(/<sup>(.*?)<\/sup>/g, `{{sup|$1}}`);
  wiki = wiki.replace(/<blockquote>(.*?)<\/blockquote>/g, `{{blockquote|text=$1}}`);

  //some formatting xml, we'll keep their insides though
  wiki = wiki.replace(/ ?<[ /]?(p|sub|sup|span|nowiki|div|table|br|tr|td|th|pre|pre2|hr|u)[ /]?> ?/g, ' '); //<sub>, </sub>
  wiki = wiki.replace(/ ?<[ /]?(abbr|bdi|bdo|cite|del|dfn|em|ins|kbd|mark|q|s|small)[ /]?> ?/g, ' '); //<abbr>, </abbr>
  wiki = wiki.replace(/ ?<[ /]?h[0-9][ /]?> ?/g, ' '); //<h2>, </h2>
  wiki = wiki.replace(/ ?< ?br ?\/> ?/g, '\n'); //<br />
  return wiki.trim()
};

/**
 * removes unnecessary strings from the wikitext
 * it is mostly-formatting stuff can be cleaned-up first, to make life easier
 *
 * @private
 * @param {string} wiki the wikitext that needs processing
 * @returns {string} the processed text
 */
function preProcess(wiki) {
  //remove comments
  wiki = wiki.replace(/<!--[\s\S]{0,3000}?-->/g, '');
  wiki = wiki.replace(/__(NOTOC|NOEDITSECTION|FORCETOC|TOC)__/gi, '');
  //signitures
  wiki = wiki.replace(/~{2,3}/g, '');
  //windows newlines
  wiki = wiki.replace(/\r/g, '');
  //japanese periods - '。'
  wiki = wiki.replace(/\u3002/g, '. ');
  //horizontal rule
  wiki = wiki.replace(/----/g, '');
  //formatting for templates-in-templates...
  wiki = wiki.replace(/\{\{\}\}/g, ' – ');
  wiki = wiki.replace(/\{\{\\\}\}/g, ' / ');
  // some html escaping
  wiki = wiki.replace(/&nbsp;/g, ' ');
  wiki = wiki.replace(/&ndash;/g, '–');

  //give it the inglorious send-off it deserves..
  wiki = kill_xml(wiki);
  //({{template}},{{template}}) leaves empty parentheses
  wiki = wiki.replace(/\([,;: ]+\)/g, '');
  //these templates just screw things up, too
  wiki = wiki.replace(/\{\{(baseball|basketball) (primary|secondary) (style|color).*?\}\}/i, '');

  return wiki
}

//dumpster-dive throws everything into mongodb  - github.com/spencermountain/dumpster-dive
//mongo has some opinions about what characters are allowed as keys and ids.
//https://stackoverflow.com/questions/12397118/mongodb-dot-in-key-name/30254815#30254815
const specialChar = /[\\.$]/;

/**
 * this function encodes a string to make it mongodb compatible.
 * https://stackoverflow.com/questions/12397118/mongodb-dot-in-key-name/30254815#30254815
 *
 * @param {string} str
 * @returns {string} the encoded string
 */
const encodeStr = function (str) {
  if (typeof str !== 'string') {
    str = '';
  }
  str = str.replace(/\\/g, '\\\\');
  str = str.replace(/^\$/, '\\u0024');
  str = str.replace(/\./g, '\\u002e');
  return str
};

const encodeObj = function (obj = {}) {
  let keys = Object.keys(obj);
  for (let i = 0; i < keys.length; i += 1) {
    if (specialChar.test(keys[i]) === true) {
      let str = encodeStr(keys[i]);
      if (str !== keys[i]) {
        obj[str] = obj[keys[i]];
        delete obj[keys[i]];
      }
    }
  }
  return obj
};

const defaults$9 = {
  headers: true,
  depth: true,
  paragraphs: true,
  images: true,
  tables: true,
  templates: true,
  infoboxes: true,
  lists: true,
  references: true,
};

/**
 *
 * @param {object} section
 * @param {object} options
 * @returns {object}
 */
const toJSON$1 = function (section, options) {
  options = setDefaults(options, defaults$9);
  /**
   * @type {object}
   */
  let data = {};

  if (options.headers === true) {
    data.title = section.title();
  }

  if (options.depth === true) {
    data.depth = section.depth();
  }

  //these return objects
  if (options.paragraphs === true) {
    let paragraphs = section.paragraphs().map((p) => p.json(options));
    if (paragraphs.length > 0) {
      data.paragraphs = paragraphs;
    }
  }

  //image json data
  if (options.images === true) {
    let images = section.images().map((img) => img.json(options));
    if (images.length > 0) {
      data.images = images;
    }
  }

  //table json data
  if (options.tables === true) {
    let tables = section.tables().map((t) => t.json(options));
    if (tables.length > 0) {
      data.tables = tables;
    }
  }

  //template json data
  if (options.templates === true) {
    let templates = section.templates().map((tmpl) => tmpl.json());
    if (templates.length > 0) {
      data.templates = templates;
      //encode them, for mongodb
      if (options.encode === true) {
        data.templates.forEach((t) => encodeObj(t));
      }
    }
  }
  //infobox json data
  if (options.infoboxes === true) {
    let infoboxes = section.infoboxes().map((i) => i.json(options));
    if (infoboxes.length > 0) {
      data.infoboxes = infoboxes;
    }
  }
  //list json data
  if (options.lists === true) {
    let lists = section.lists().map((list) => list.json(options));
    if (lists.length > 0) {
      data.lists = lists;
    }
  }
  //list references - default true
  if (options.references === true || options.citations === true) {
    let references = section.references().map((ref) => ref.json(options));
    if (references.length > 0) {
      data.references = references;
    }
  }
  //default off
  if (options.sentences === true) {
    data.sentences = section.sentences().map((s) => s.json(options));
  }
  return data
};

const defaults$8 = {
  type: 'internal',
};
const Link = function (data) {
  data = data || {};
  data = Object.assign({}, defaults$8, data);
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
};
const methods$7 = {
  text: function (str) {
    if (str !== undefined) {
      this.data.text = str;
    }
    let txt = this.data.text || this.data.page || '';
    // remove bold/italics
    txt = txt.replace(/'{2,}/g, '');
    return txt
  },
  json: function () {
    let obj = {
      text: this.data.text,
      type: this.type(),
    };
    if (obj.type === 'internal') {
      obj.page = this.page();
    } else if (obj.type === 'interwiki') {
      obj.wiki = this.wiki();
      obj.page = this.page();
    } else {
      obj.site = this.site();
    }
    let anchor = this.anchor();
    if (anchor) {
      obj.anchor = anchor;
    }
    return obj
  },
  wikitext: function () {
    let txt = this.data.raw || '';
    return txt
  },
  page: function (str) {
    if (str !== undefined) {
      this.data.page = str;
    }
    return this.data.page
  },
  anchor: function (str) {
    if (str !== undefined) {
      this.data.anchor = str;
    }
    return this.data.anchor || ''
  },
  wiki: function (str) {
    if (str !== undefined) {
      this.data.wiki = str;
    }
    return this.data.wiki
  },
  type: function (str) {
    if (str !== undefined) {
      this.data.type = str;
    }
    return this.data.type
  },
  site: function (str) {
    if (str !== undefined) {
      this.data.site = str;
    }
    return this.data.site
  },
  //create a url for any type of link
  href: function () {
    let type = this.type();
    if (type === 'external') {
      return this.site()
    }
    let page = this.page();
    page = page.replace(/ /g, '_');
    page = encodeURIComponent(page);
    let url = '';

    if (type === 'interwiki') {
      let wiki = this.wiki();
      url = 'https://en.wikipedia.org/wiki/$1';
      if (wikis.hasOwnProperty(wiki)) {
        url = 'http://' + wikis[this.wiki()];
      }
      url = url.replace(/\$1/g, page);
    } else {
      //internal link
      url = `./${this.page()}`;
    }
    //add anchor on the end
    if (this.anchor()) {
      url += '#' + this.anchor();
    }
    return url
  },
};
Object.keys(methods$7).forEach((k) => {
  Link.prototype[k] = methods$7[k];
});

//return only rendered text of wiki links
const removeLinks = function (line) {
  // [[File:with|Size]]
  line = line.replace(/\[\[File:(.{2,80}?)\|([^\]]+)\]\](\w{0,5})/g, '$1');
  return line
};

const getLinks = function (data) {
  let wiki = data.text;
  let links = parse_links(wiki) || [];
  data.links = links.map((link) => {
    wiki = wiki.replace(link.raw, link.text || link.page || '');
    // delete link.raw
    return new Link(link)
  });
  wiki = removeLinks(wiki);
  data.text = wiki;
};

//handle the bold/italics
const formatting = function (obj) {
  let bolds = [];
  let italics = [];
  let wiki = obj.text || '';
  //bold and italics combined 5 's
  wiki = wiki.replace(/'''''(.{0,2500}?)'''''/g, (a, b) => {
    bolds.push(b);
    italics.push(b);
    return b
  });
  //''''four'''' → bold with quotes
  wiki = wiki.replace(/''''(.{0,2500}?)''''/g, (a, b) => {
    bolds.push(`'${b}'`);
    return `'${b}'`
  });
  //'''bold'''
  wiki = wiki.replace(/'''(.{0,2500}?)'''/g, (a, b) => {
    bolds.push(b);
    return b
  });
  //''italic''
  wiki = wiki.replace(/''(.{0,2500}?)''/g, (a, b) => {
    italics.push(b);
    return b
  });

  //pack it all up..
  obj.text = wiki;
  if (bolds.length > 0) {
    obj.fmt = obj.fmt || {};
    obj.fmt.bold = bolds;
  }
  if (italics.length > 0) {
    obj.fmt = obj.fmt || {};
    obj.fmt.italic = italics;
  }
  return obj
};

const isNumber = /^[0-9,.]+$/;

const defaults$7 = {
  text: true,
  links: true,
  formatting: true,
  numbers: true,
};

/**
 * @private
 * */
const toJSON = function (s, options) {
  options = setDefaults(options, defaults$7);
  let data = {};
  let text = s.text();
  if (options.text === true) {
    data.text = text;
  }
  //add number field
  if (options.numbers === true && isNumber.test(text)) {
    let num = Number(text.replace(/,/g, ''));
    if (isNaN(num) === false) {
      data.number = num;
    }
  }
  if (options.links && s.links().length > 0) {
    data.links = s.links().map((l) => l.json());
  }
  if (options.formatting && s.data.fmt) {
    data.formatting = s.data.fmt;
  }
  return data
};

//where we store the formatting, link, date information
const Sentence = function (data = {}) {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
};

const methods$6 = {
  links: function (n) {
    let arr = this.data.links || [];
    if (typeof n === 'string') {
      //grab a link like .links('Fortnight')
      n = n.charAt(0).toUpperCase() + n.substring(1); //titlecase it
      let link = arr.find((o) => o.page === n);
      return link === undefined ? [] : [link]
    }
    return arr
  },
  interwiki: function () {
    return this.links().filter((l) => l.wiki !== undefined)
  },
  bolds: function () {
    if (this.data && this.data.fmt && this.data.fmt.bold) {
      return this.data.fmt.bold || []
    }
    return []
  },
  italics: function () {
    if (this.data && this.data.fmt && this.data.fmt.italic) {
      return this.data.fmt.italic || []
    }
    return []
  },
  text: function (str) {
    if (str !== undefined && typeof str === 'string') {
      //set the text?
      this.data.text = str;
    }
    return this.data.text || ''
  },
  json: function (options) {
    return toJSON(this, options)
  },
  wikitext: function () {
    return this.data.wiki || ''
  },
  isEmpty: function () {
    return this.data.text === ''
  },
};

Object.keys(methods$6).forEach((k) => {
  Sentence.prototype[k] = methods$6[k];
});

// aliases
const singular$3 = {
  links: 'link',
  bolds: 'bold',
  italics: 'italic',
};
Object.keys(singular$3).forEach((k) => {
  let sing = singular$3[k];
  Sentence.prototype[sing] = function (clue) {
    let arr = this[k](clue);
    if (typeof clue === 'number') {
      return arr[clue]
    }
    return arr[0]
  };
});

Sentence.prototype.plaintext = Sentence.prototype.text;

//these are used for the sentence-splitter
var literalAbbreviations = [
  'ad',
  'adj',
  'adm',
  'adv',
  'al',
  'alta',
  'approx',
  'apr',
  'apt',
  'arc',
  'ariz',
  'assn',
  'asst',
  'atty',
  'aug',
  'ave',
  'ba',
  'bc',
  'bl',
  'bldg',
  'blvd',
  'brig',
  'bros',
  'ca',
  'cal',
  'calif',
  'capt',
  'cca',
  'cg',
  'cl',
  'cm',
  'cmdr',
  'co',
  'col',
  'colo',
  'comdr',
  'conn',
  'corp',
  'cpl',
  'cres',
  'ct',
  'cyn',
  'dak',
  'dec',
  'def',
  'dept',
  'det',
  'dg',
  'dist',
  'dl',
  'dm',
  'dr',
  'ea',
  'eg',
  'eng',
  'esp',
  'esq',
  'est',
  'etc',
  'ex',
  'exp',
  'feb',
  'fem',
  'fig',
  'fl oz',
  'fl',
  'fla',
  'fm',
  'fr',
  'ft',
  'fy',
  'ga',
  'gal',
  'gb',
  'gen',
  'gov',
  'hg',
  'hon',
  'hr',
  'hrs',
  'hwy',
  'hz',
  'ia',
  'ida',
  'ie',
  'inc',
  'inf',
  'jan',
  'jd',
  'jr',
  'jul',
  'jun',
  'kan',
  'kans',
  'kb',
  'kg',
  'km',
  'kmph',
  'lat',
  'lb',
  'lit',
  'llb',
  'lm',
  'lng',
  'lt',
  'ltd',
  'lx',
  'ma',
  'maj',
  'mar',
  'masc',
  'mb',
  'md',
  'messrs',
  'mg',
  'mi',
  'min',
  'minn',
  'misc',
  'mister',
  'ml',
  'mlle',
  'mm',
  'mme',
  'mph',
  'mps',
  'mr',
  'mrs',
  'ms',
  'mstr',
  'mt',
  'neb',
  'nebr',
  'nee',
  'no',
  'nov',
  'oct',
  'okla',
  'ont',
  'op',
  'ord',
  'oz',
  'pa',
  'pd',
  'penn',
  'penna',
  'phd',
  'pl',
  'pp',
  'pref',
  'prob',
  'prof',
  'pron',
  'ps',
  'psa',
  'pseud',
  'pt',
  'pvt',
  'qt',
  'que',
  'rb',
  'rd',
  'rep',
  'reps',
  'res',
  'rev',
  'sask',
  'sec',
  'sen',
  'sens',
  'sep',
  'sept',
  'sfc',
  'sgt',
  'sir',
  'situ',
  'sq ft',
  'sq',
  'sr',
  'ss',
  'st',
  'ste',
  'supt',
  'surg',
  'tb',
  'tbl',
  'tbsp',
  'tce',
  'td',
  'tel',
  'temp',
  'tenn',
  'tex',
  'tsp',
  'univ',
  'usafa',
  'ut',
  'va',
  'vb',
  'ver',
  'vet',
  'vitro',
  'vivo',
  'vol',
  'vs',
  'vt',
  'wis',
  'wisc',
  'wr',
  'wy',
  'wyo',
  'yb',
  'µg',
];

//split text into sentences, using regex
//@spencermountain MIT

const abbreviations = literalAbbreviations.concat('[^]][^]]');
const abbrev_reg = new RegExp("(^| |')(" + abbreviations.join('|') + `)[.!?] ?$`, 'i');
const acronym_reg = /[ .'][A-Z].? *$/i;
const elipses_reg = /\.{3,} +$/;
const circa_reg = / c\.\s$/;
const hasWord = /\p{Letter}/iu;

//turn a nested array into one array
const flatten = function (arr) {
  let all = [];
  arr.forEach(function (a) {
    all = all.concat(a);
  });
  return all
};

const naiive_split = function (text) {
  //first, split by newline
  let splits = text.split(/(\n+)/);
  splits = splits.filter((s) => s.match(/\S/));
  //split by period, question-mark, and exclamation-mark
  splits = splits.map(function (str) {
    return str.split(/(\S.+?[.!?]"?)(?=\s|$)/g) //\u3002
  });
  return flatten(splits)
};

// if this looks like a period within a wikipedia link, return false
const isBalanced = function (str) {
  str = str || '';
  const open = str.split(/\[\[/) || [];
  const closed = str.split(/\]\]/) || [];
  if (open.length > closed.length) {
    return false
  }
  //make sure quotes are closed too
  const quotes = str.match(/"/g);
  if (quotes && quotes.length % 2 !== 0 && str.length < 900) {
    return false
  }
  //make sure quotes are closed too
  const parens = str.match(/[()]/g);
  if (parens && parens.length % 2 !== 0 && str.length < 900) {
    return false
  }
  return true
};

const sentence_parser = function (text) {
  let sentences = [];
  //first do a greedy-split..
  let chunks = [];
  //ensure it 'smells like' a sentence
  if (!text || typeof text !== 'string' || text.trim().length === 0) {
    return sentences
  }
  // This was the splitter regex updated to fix quoted punctuation marks.
  // let splits = text.split(/(\S.+?[.\?!])(?=\s+|$|")/g);
  // todo: look for side effects in this regex replacement:
  let splits = naiive_split(text);
  //filter-out the grap ones
  for (let i = 0; i < splits.length; i++) {
    let s = splits[i];
    if (!s || s === '') {
      continue
    }
    //this is meaningful whitespace
    if (!s.match(/\S/)) {
      //add it to the last one
      if (chunks[chunks.length - 1]) {
        chunks[chunks.length - 1] += s;
        continue
      } else if (splits[i + 1]) {
        //add it to the next one
        splits[i + 1] = s + splits[i + 1];
        continue
      }
    }
    chunks.push(s);
  }

  //detection of non-sentence chunks
  const isSentence = function (hmm) {
    if (hmm.match(abbrev_reg) || hmm.match(acronym_reg) || hmm.match(elipses_reg) || hmm.match(circa_reg)) {
      return false
    }
    //too short? - no consecutive letters
    if (hasWord.test(hmm) === false) {
      return false
    }
    if (!isBalanced(hmm)) {
      return false
    }
    return true
  };
  //loop through these chunks, and join the non-sentence chunks back together..
  for (let i = 0; i < chunks.length; i++) {
    //should this chunk be combined with the next one?
    if (chunks[i + 1] && !isSentence(chunks[i])) {
      // need a space to connect these?
      if (!/^\s/.test(chunks[i + 1]) && !/\s$/.test(chunks[i])) {
        chunks[i + 1] = chunks[i] + ' ' + chunks[i + 1];
      } else {
        chunks[i + 1] = chunks[i] + chunks[i + 1];
      }
    } else if (chunks[i] && chunks[i].length > 0) {
      //this chunk is a proper sentence..
      sentences.push(chunks[i]);
      chunks[i] = '';
    }
  }
  //if we never got a sentence, return the given text
  if (sentences.length === 0) {
    return [text]
  }
  return sentences
};

/**
 * This function removes some final characters from the sentence
 *
 * @private
 * @param {string} line the wiki text for processing
 * @returns {string} the processed string
 */
function postprocess(line) {
  //remove empty parentheses (sometimes caused by removing templates)
  line = line.replace(/\([,;: ]*\)/g, '');
  //these semi-colons in parentheses are particularly troublesome
  line = line.replace(/\( *(; ?)+/g, '(');
  //dangling punctuation
  line = trim_whitespace(line);
  line = line.replace(/ +\.$/, '.');
  return line
}

/**
 * returns one sentence object
 *
 * @param {string} str create a object from a sentence
 * @returns {Sentence} the Sentence created from the text
 */
function fromText(str) {
  let obj = {
    wiki: str,
    text: str,
  };
  //pull-out the [[links]]
  getLinks(obj);
  obj.text = postprocess(obj.text);
  //pull-out the bolds and ''italics''
  obj = formatting(obj);
  //pull-out things like {{start date|...}}
  return new Sentence(obj)
}

//used for consistency with other class-definitions
const byParagraph = function (paragraph) {
  //array of texts
  let sentences = sentence_parser(paragraph.wiki);
  //sentence objects
  sentences = sentences.map(fromText);
  //remove :indented first line, as it is often a disambiguation
  if (sentences[0] && sentences[0].text() && sentences[0].text()[0] === ':') {
    sentences = sentences.slice(1);
  }
  paragraph.sentences = sentences;
};

//remove top-bottoms
const cleanup$1 = function (lines) {
  lines = lines.filter((line) => {
    //a '|+' row is a 'table caption', remove it.
    return line && /^\|\+/.test(line) !== true
  });
  if (/^\{\|/.test(lines[0]) === true) {
    lines.shift();
  }
  if (/^\|\}/.test(lines[lines.length - 1]) === true) {
    lines.pop();
  }
  if (/^\|-/.test(lines[0]) === true) {
    lines.shift();
  }
  return lines
};

//turn newline seperated into '|-' seperated
const findRows = function (lines) {
  let rows = [];
  let row = [];
  lines = cleanup$1(lines);
  for (let i = 0; i < lines.length; i += 1) {
    let line = lines[i];
    //'|-' is a row-seperator
    if (/^\|-/.test(line) === true) {
      //okay, we're done the row
      if (row.length > 0) {
        rows.push(row);
        row = [];
      }
    } else {
      // remove leading | or ! for the ||/!! splitting
      let startChar = line.charAt(0);
      if (startChar === '|' || startChar === '!') {
        line = line.substring(1);
      }
      //look for '||' inline row-splitter
      line = line.split(/(?:\|\||!!)/); //eslint-disable-line
      // add leading ! back, because we later read it in header parsing functions
      if (startChar === '!') {
        line[0] = startChar + line[0];
      }
      line.forEach((l) => {
        l = l.trim();
        row.push(l);
      });
    }
  }
  //finish the last one
  if (row.length > 0) {
    rows.push(row);
  }
  return rows
};

const getRowSpan = /.*rowspan *= *["']?([0-9]+)["']?[ |]*/;
const getColSpan = /.*colspan *= *["']?([0-9]+)["']?[ |]*/;

//colspans stretch ←left/right→
const doColSpan = function (rows) {
  rows.forEach((row) => {
    row.forEach((str, c) => {
      let m = str.match(getColSpan);
      if (m !== null) {
        let num = parseInt(m[1], 10);

        //...maybe if num is so big, and centered, remove it?
        // if (num > 3) {
        //   rows[r] = []
        //   return
        // }
        //splice-in n empty columns right here
        row[c] = str.replace(getColSpan, '');
        for (let i = 1; i < num; i += 1) {
          row.splice(c + 1, 0, '');
        }
      }
    });
  });
  rows = rows.filter((r) => r.length > 0);
  return rows
};

//colspans stretch up/down
const doRowSpan = function (rows) {
  rows.forEach((row, r) => {
    row.forEach((str, c) => {
      let m = str.match(getRowSpan);
      if (m !== null) {
        let num = parseInt(m[1], 10);
        //copy this cell down n rows
        str = str.replace(getRowSpan, '');
        row[c] = str;
        for (let i = r + 1; i < r + num; i += 1) {
          if (!rows[i]) {
            break
          }
          rows[i].splice(c, 0, str);
        }
      }
    });
  });
  return rows
};

//
const handleSpans = function (rows) {
  rows = doColSpan(rows);
  rows = doRowSpan(rows);
  return rows
};

const isHeading = /^!/;

//common ones
const headings$1 = {
  name: true,
  age: true,
  born: true,
  date: true,
  year: true,
  city: true,
  country: true,
  population: true,
  count: true,
  number: true,
};

//additional table-cruft to remove before parseLine method
const cleanText = function (str) {
  str = fromText(str).text();
  //anything before a single-pipe is styling, so remove it
  if (str.match(/\|/)) {
    str = str.replace(/.*?\| ?/, ''); //class="unsortable"|title
  }
  str = str.replace(/style=['"].*?["']/, '');
  //'!' is used as a highlighed-column
  str = str.replace(/^!/, '');
  // str = str.replace(/\(.*?\)/, '')
  str = str.trim();
  // str = str.toLowerCase()
  return str
};

const skipSpanRow = function (row) {
  row = row || [];
  let len = row.length;
  let hasTxt = row.filter((str) => str).length;
  //does it have 3 empty spaces?
  if (len - hasTxt > 3) {
    return true
  }
  return false
};

//remove non-header span rows
const removeMidSpans = function (rows) {
  rows = rows.filter((row) => {
    if (row.length === 1 && row[0] && isHeading.test(row[0]) && /rowspan/i.test(row[0]) === false) {
      return false
    }
    return true
  });
  return rows
};

//'!' starts a header-row
const findHeaders = function (rows = []) {
  let headers = [];

  // is the first-row just a ton of colspan?
  if (skipSpanRow(rows[0])) {
    rows.shift();
  }

  let first = rows[0];
  if (first && first[0] && first[1] && (/^!/.test(first[0]) || /^!/.test(first[1]))) {
    headers = first.map((h) => {
      h = h.replace(/^! */, '');
      h = cleanText(h);
      return h
    });
    rows.shift();
  }
  //try the second row, too (overwrite first-row, if it exists)
  first = rows[0];
  if (first && first[0] && first[1] && /^!/.test(first[0]) && /^!/.test(first[1])) {
    first.forEach((h, i) => {
      h = h.replace(/^! */, '');
      h = cleanText(h);
      if (Boolean(h) === true) {
        headers[i] = h;
      }
    });
    rows.shift();
  }
  return headers
};

//turn headers, array into an object
const parseRow = function (arr, headers) {
  let row = {};
  arr.forEach((str, i) => {
    let h = headers[i] || 'col' + (i + 1);
    let s = fromText(str);
    s.text(cleanText(s.text()));
    row[h] = s;
  });
  return row
};

//should we use the first row as a the headers?
const firstRowHeader = function (rows) {
  if (rows.length <= 3) {
    return []
  }
  let headers = rows[0].slice(0);
  headers = headers.map((h) => {
    h = h.replace(/^! */, '');
    h = fromText(h).text();
    h = cleanText(h);
    h = h.toLowerCase();
    return h
  });
  for (let i = 0; i < headers.length; i += 1) {
    if (headings$1.hasOwnProperty(headers[i])) {
      rows.shift();
      return headers
    }
  }
  return []
};

//turn a {|...table string into an array of arrays
const parseTable = function (wiki) {
  let lines = wiki
    .replace(/\r/g, '')
    .replace(/\n(\s*[^|!{\s])/g, ' $1') //remove unecessary newlines
    .split(/\n/)
    .map((l) => l.trim());
  let rows = findRows(lines);
  rows = rows.filter((r) => r);
  if (rows.length === 0) {
    return []
  }

  //remove non-header span rows
  rows = removeMidSpans(rows);
  //support colspan, rowspan...
  rows = handleSpans(rows);
  //grab the header rows
  let headers = findHeaders(rows);
  if (!headers || headers.length <= 1) {
    headers = firstRowHeader(rows);
    let want = rows[rows.length - 1] || [];
    //try the second row
    if (headers.length <= 1 && want.length > 2) {
      headers = firstRowHeader(rows.slice(1));
      if (headers.length > 0) {
        rows = rows.slice(2); //remove them
      }
    }
  }
  //index each column by it's header
  let table = rows.map((arr) => {
    return parseRow(arr, headers)
  });
  return table
};

//
const toJson$2 = function (tables, options) {
  return tables.map((table) => {
    let row = {};
    Object.keys(table).forEach((k) => {
      row[k] = table[k].json(); //(they're sentence objects)
    });
    //encode them, for mongodb
    if (options.encode === true) {
      row = encodeObj(row);
    }
    return row
  })
};

const defaults$6 = {};

const normalize$1 = function (key = '') {
  key = key.toLowerCase();
  key = key.replace(/[_-]/g, ' ');
  key = key.replace(/\(.*?\)/, '');
  key = key.trim();
  return key
};

const Table = function (data, wiki = '') {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
  Object.defineProperty(this, '_wiki', {
    enumerable: false,
    value: wiki,
  });
};

const methods$5 = {
  links(n) {
    let links = [];
    this.data.forEach((r) => {
      Object.keys(r).forEach((k) => {
        links = links.concat(r[k].links());
      });
    });
    if (typeof n === 'string') {
      //grab a link like .links('Fortnight')
      n = n.charAt(0).toUpperCase() + n.substring(1); //titlecase it
      let link = links.find((o) => o.page() === n);
      return link === undefined ? [] : [link]
    }
    return links
  },
  get(keys) {
    // normalize mappings
    let have = this.data[0] || {};
    let mapping = Object.keys(have).reduce((h, k) => {
      h[normalize$1(k)] = k;
      return h
    }, {});
    // string gets a flat-list
    if (typeof keys === 'string') {
      let key = normalize$1(keys);
      key = mapping[key] || key;
      return this.data.map((row) => {
        return row[key] ? row[key].text() : null
      })
    }
    // array gets obj-list
    keys = keys.map(normalize$1).map((k) => mapping[k] || k);
    return this.data.map((row) => {
      return keys.reduce((h, k) => {
        if (row[k]) {
          h[k] = row[k].text();
        } else {
          h[k] = '';
        }
        return h
      }, {})
    })
  },
  keyValue(options) {
    let rows = this.json(options);
    rows.forEach((row) => {
      Object.keys(row).forEach((k) => {
        row[k] = row[k].text;
      });
    });
    return rows
  },
  json(options) {
    options = setDefaults(options, defaults$6);
    return toJson$2(this.data, options)
  },

  text() {
    return ''
  },

  wikitext() {
    return this._wiki || ''
  },
};
methods$5.keyvalue = methods$5.keyValue;
methods$5.keyval = methods$5.keyValue;

Object.keys(methods$5).forEach((k) => {
  Table.prototype[k] = methods$5[k];
});

//const table_reg = /\{\|[\s\S]+?\|\}/g; //the largest-cities table is ~70k chars.
const openReg = /^\s*\{\|/;
const closeReg = /^\s*\|\}/;

//tables can be recursive, so looky-here.
const findTables = function (section) {
  let list = [];
  let wiki = section._wiki;
  let lines = wiki.split('\n');
  let stack = [];
  for (let i = 0; i < lines.length; i += 1) {
    //start a table
    if (openReg.test(lines[i]) === true) {
      stack.push(lines[i]);
      continue
    }
    //close a table
    if (closeReg.test(lines[i]) === true) {
      stack[stack.length - 1] += '\n' + lines[i];
      let table = stack.pop();
      list.push(table);
      continue
    }
    //keep-going on one
    if (stack.length > 0) {
      stack[stack.length - 1] += '\n' + lines[i];
    }
  }
  //work-em together for a Table class
  let tables = [];
  list.forEach((str) => {
    if (str) {
      //also re-remove a newline at the end of the table (awkward)
      wiki = wiki.replace(str + '\n', '');
      wiki = wiki.replace(str, '');
      let data = parseTable(str);
      if (data && data.length > 0) {
        tables.push(new Table(data, str));
      }
    }
  });

  if (tables.length > 0) {
    section._tables = tables;
  }
  section._wiki = wiki;
};

const defaults$5 = {
  sentences: true,
};

const toJson$1 = function (p, options) {
  options = setDefaults(options, defaults$5);
  let data = {};
  if (options.sentences === true) {
    data.sentences = p.sentences().map((s) => s.json(options));
  }
  return data
};

const defaults$4 = {
  sentences: true,
  lists: true,
  images: true,
};

const Paragraph = function (data) {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
};

const methods$4 = {
  sentences: function () {
    return this.data.sentences || []
  },
  references: function () {
    return this.data.references
  },
  lists: function () {
    return this.data.lists
  },
  images() {
    return this.data.images || []
  },
  links: function (clue) {
    let arr = [];
    this.sentences().forEach((s) => {
      arr = arr.concat(s.links(clue));
    });
    if (typeof clue === 'string') {
      //grab a specific link like .links('Fortnight')
      clue = clue.charAt(0).toUpperCase() + clue.substring(1); //titlecase it
      let link = arr.find((o) => o.page() === clue);
      return link === undefined ? [] : [link]
    }
    return arr || []
  },
  interwiki() {
    let arr = [];
    this.sentences().forEach((s) => {
      arr = arr.concat(s.interwiki());
    });
    return arr || []
  },
  text: function (options) {
    options = setDefaults(options, defaults$4);
    let str = this.sentences()
      .map((s) => s.text(options))
      .join(' ');
    this.lists().forEach((list) => {
      str += '\n' + list.text();
    });
    return str
  },
  json: function (options) {
    options = setDefaults(options, defaults$4);
    return toJson$1(this, options)
  },
  wikitext: function () {
    return this.data.wiki
  },
};
methods$4.citations = methods$4.references;
Object.keys(methods$4).forEach((k) => {
  Paragraph.prototype[k] = methods$4[k];
});

// aliases
const singular$2 = {
  sentences: 'sentence',
  references: 'reference',
  citations: 'citation',
  lists: 'list',
  images: 'image',
  links: 'link',
};
Object.keys(singular$2).forEach((k) => {
  let sing = singular$2[k];
  Paragraph.prototype[sing] = function (clue) {
    let arr = this[k](clue);
    if (typeof clue === 'number') {
      return arr[clue]
    }
    return arr[0]
  };
});

/**
 * removes the top and bottom off the template
 * so it removes tje '{{' and '}}'
 *
 * @private
 * @param {string} tmpl the string to be striped
 * @returns {string} the striped string
 */
const strip = function (tmpl) {
  tmpl = tmpl.replace(/^\{\{/, '');
  tmpl = tmpl.replace(/\}\}$/, '');
  return tmpl
};

//normalize template names
const fmtName = function (name) {
  name = (name || '').trim();
  name = name.toLowerCase();
  name = name.replace(/_/g, ' ');
  return name
};

/**
 * turn {{name|one|two|three}} into [name, one, two, three]
 *
 * @private
 * @param {string} tmpl the template text
 * @returns {string[]} a array containing all the split parameters
 */
const pipeSplitter = function (tmpl) {
  //start with a naive '|' split
  let arr = tmpl.split(/\n?\|/);
  //we've split by '|', which is pretty lame
  //look for broken-up links and fix them :/
  arr.forEach((a, i) => {
    if (a === null) {
      return
    }
    //has '[[' but no ']]'
    //has equal number of opening and closing tags. handle nested case '[[[[' ']]'
    if (
      /\[\[[^\]]+$/.test(a) ||
      /\{\{[^}]+$/.test(a) ||
      a.split('{{').length !== a.split('}}').length ||
      a.split('[[').length !== a.split(']]').length
    ) {
      arr[i + 1] = arr[i] + '|' + arr[i + 1];
      arr[i] = null;
    }
  });
  //cleanup any mistakes we've made
  arr = arr.filter((a) => a !== null);
  arr = arr.map((a) => (a || '').trim());

  //remove empty fields, only at the end:
  for (let i = arr.length - 1; i >= 0; i -= 1) {
    if (arr[i] === '') {
      arr.pop();
    }
    break
  }
  return arr
};

//every value in {{tmpl|a|b|c}} needs a name
//here we come up with names for them
const hasKey = /^[\p{Letter}0-9._/\- '()\t]+=/iu;

//templates with these properties are asking for trouble
const reserved = {
  template: true,
  list: true,
  prototype: true,
};

/**
 * @typedef parseKeyReturn
 * @property {string} val
 * @property {string} key
 */

/**
 * turn 'key=val' into {key:key, val:val}
 *
 * @param {string} str the string that will be parsed
 * @returns {parseKeyReturn} the spit string
 */
const parseKey = function (str) {
  let parts = str.split('=');
  let key = parts[0] || '';
  key = key.toLowerCase().trim();
  let val = parts.slice(1).join('=');
  //don't let it be called 'template'..
  if (reserved.hasOwnProperty(key)) {
    key = '_' + key;
  }
  return {
    key: key,
    val: val.trim(),
  }
};

/**
 * turn [a, b=v, c] into {'1':a, b:v, '2':c}
 *
 * @private
 * @param {string[]} arr the array of parameters
 * @param {string[]} [order] the order in which the parameters are returned
 * @returns {object} and object with the names as the keys and the values as the values
 */
const keyMaker = function (arr, order) {
  let keyIndex = 0;
  return arr.reduce((h, str = '') => {
    str = str.trim();

    //support named keys - 'foo=bar'
    if (hasKey.test(str) === true) {
      let res = parseKey(str);
      if (res.key) {
        // don't overwrite if empty
        if (h[res.key] && !res.val) {
          return h
        }
        h[res.key] = res.val;
        return h
      }
    }

    //if the current index is present in the order array then we have a name for the key
    if (order && order[keyIndex]) {
      let key = order[keyIndex];
      h[key] = str;
    } else {
      h.list = h.list || [];
      h.list.push(str);
    }

    keyIndex += 1;
    return h
  }, {})
};

const whoCares = {
  classname: true,
  style: true,
  align: true,
  margin: true,
  left: true,
  break: true,
  boxsize: true,
  framestyle: true,
  item_style: true,
  collapsible: true,
  list_style_type: true,
  'list-style-type': true,
  colwidth: true,
};

//remove wiki-cruft & some styling info from templates
const cleanup = function (obj) {
  Object.keys(obj).forEach((k) => {
    if (whoCares[k.toLowerCase()] === true) {
      delete obj[k];
    }
    //remove empty values, too
    if (obj[k] === null || obj[k] === '') {
      delete obj[k];
    }
  });
  return obj
};

//remove the top/bottom off the template

/**
 * most templates just want plaintext...
 *
 * @private
 * @param {str} str
 * @param {'json' | 'raw'} [fmt]
 * @returns {string} text
 */
const makeFormat = function (str, fmt) {
  let s = fromText(str);
  //support various output formats
  if (fmt === 'json') {
    return s.json()
  } else if (fmt === 'raw') {
    return s
  }
  //default to flat text
  return s.text()
};

/**
 * parses the parameters of a template to a usable format
 *
 * @private
 * @param {string} tmpl the template text
 * @param {string[]} [order] the order in which the parameters are returned
 * @param {'json' | 'raw'} [fmt] whether you wan to parse the text of the template the raw object or just the text
 * @returns {object} the parameters of the template in a usable format
 */
const parser = function (tmpl, order = [], fmt) {
  //remove {{}}'s and split based on pipes
  tmpl = strip(tmpl || '');
  let arr = pipeSplitter(tmpl);
  //get template name
  let name = arr.shift();

  //name each value
  let obj = keyMaker(arr, order);

  //remove wiki-junk
  obj = cleanup(obj);

  //is this a infobox/reference?
  //let known = isKnown(obj);

  //using '|1=content' is an escaping-thing..
  if (obj['1'] && order[0] && obj.hasOwnProperty(order[0]) === false) {
    //move it over..
    obj[order[0]] = obj['1'];
    delete obj['1'];
  }

  Object.keys(obj).forEach((k) => {
    if (k === 'list') {
      obj[k] = obj[k].map((v) => makeFormat(v, fmt));
      return
    }
    obj[k] = makeFormat(obj[k], fmt);
  });

  //add the template name
  if (name) {
    obj.template = fmtName(name);
  }
  return obj
};

const opener = '[';
const closer = ']';

/**
 *
 * find all the pairs of '[[...[[..]]...]]' in the text
 * used to properly root out recursive template calls, [[.. [[...]] ]]
 * basically just adds open tags, and subtracts closing tags
 *
 * @private
 * @param {string} text the text in which is searched in
 * @returns {string[]} all the links in the text
 */
function nested_find(text) {
  let out = [];
  let last = [];
  const chars = text.split('');
  let open = 0;
  for (let i = 0; i < chars.length; i++) {
    const c = text[i];
    //increment open tag
    if (c === opener) {
      open += 1;
    }
    //decrement close tag
    else if (c === closer) {
      open -= 1;
      if (open < 0) {
        open = 0;
      }
    } else if (last.length === 0) {
      //If we're not inside of a pair of delimiters, we can discard the current letter.
      //The return of this function is only used to extract images.
      continue
    }

    last.push(c);
    if (open === 0 && last.length > 0) {
      //first, fix botched parse
      let open_count = 0;
      let close_count = 0;
      for (let j = 0; j < last.length; j++) {
        if (last[j] === opener) {
          open_count++;
        } else if (last[j] === closer) {
          close_count++;
        }
      }
      //is it botched?
      if (open_count > close_count) {
        last.push(closer);
      }
      //looks good, keep it
      out.push(last.join(''));
      last = [];
    }
  }
  return out
}

//regexes:
const isFile = new RegExp('(' + images.join('|') + '):', 'i');
let fileNames = `(${images.join('|')})`;
const file_reg = new RegExp(fileNames + ':(.+?)[\\||\\]]', 'iu');
const linkToFile = /^\[\[:/;

//style directives for Wikipedia:Extended_image_syntax
const imgLayouts = {
  thumb: true,
  thumbnail: true,
  border: true,
  right: true,
  left: true,
  center: true,
  top: true,
  bottom: true,
  none: true,
  upright: true,
  baseline: true,
  middle: true,
  sub: true,
  super: true,
};

//images are usually [[image:my_pic.jpg]]
const oneImage = function (img, doc) {
  let m = img.match(file_reg);
  if (m === null || !m[2]) {
    return null
  }
  if (linkToFile.test(img)) {
    return null
  }
  let file = `${m[1]}:${m[2] || ''}`;
  if (file) {
    let obj = {
      file: file,
      lang: doc._lang,
      domain: doc._domain,
      wiki: img,
      pluginData: {}
    };
    //try to grab other metadata, too
    img = img.replace(/^\[\[/, '');
    img = img.replace(/\]\]$/, '');

    //https://en.wikipedia.org/wiki/Wikipedia:Extended_image_syntax
    //- [[File:Name|Type|Border|Location|Alignment|Size|link=Link|alt=Alt|lang=Langtag|Caption]]
    let imgData = parser(img);
    let arr = imgData.list || [];
    //parse-out alt text, if explicitly given
    if (imgData.alt) {
      obj.alt = imgData.alt;
    }
    //remove 'thumb' and things
    arr = arr.filter((str) => imgLayouts.hasOwnProperty(str) === false);
    if (arr[arr.length - 1]) {
      obj.caption = fromText(arr[arr.length - 1]);
    }
    return new Image(obj)
  }
  return null
};

const parseImages = function (paragraph, doc) {
  let wiki = paragraph.wiki;
  //parse+remove scary '[[ [[]] ]]' stuff
  let matches = nested_find(wiki);
  matches.forEach(function (s) {
    if (isFile.test(s) === true) {
      paragraph.images = paragraph.images || [];
      let img = oneImage(s, doc);
      if (img) {
        paragraph.images.push(img);
        wiki = wiki.replace(s, '');
      }
    }
  });
  paragraph.wiki = wiki;
};

const defaults$3 = {};

const toText$1 = (list, options) => {
  return list
    .map((s) => {
      let str = s.text(options);
      return ' * ' + str
    })
    .join('\n')
};

const List = function (data, wiki = '') {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
  Object.defineProperty(this, 'wiki', {
    enumerable: false,
    value: wiki,
  });
};

const methods$3 = {
  lines() {
    return this.data
  },
  links(clue) {
    let links = [];
    this.lines().forEach((s) => {
      links = links.concat(s.links());
    });
    if (typeof clue === 'string') {
      //grab a link like .links('Fortnight')
      clue = clue.charAt(0).toUpperCase() + clue.substring(1); //titlecase it
      let link = links.find((o) => o.page() === clue);
      return link === undefined ? [] : [link]
    }
    return links
  },
  json(options) {
    options = setDefaults(options, defaults$3);
    return this.lines().map((s) => s.json(options))
  },
  text() {
    return toText$1(this.data)
  },
  wikitext() {
    return this.wiki || ''
  },
};

Object.keys(methods$3).forEach((k) => {
  List.prototype[k] = methods$3[k];
});

const list_reg = /^[#*:;|]+/;
const bullet_reg = /^\*+[^:,|]{4}/;
const number_reg = /^ ?#[^:,|]{4}/;
const has_word = /[\p{Letter}_0-9\]}]/iu;

// does it start with a bullet point or something?
const isList = function (line) {
  return list_reg.test(line) || bullet_reg.test(line) || number_reg.test(line)
};

//make bullets/numbers into human-readable *'s
const cleanList = function (list) {
  let number = 1;
  list = list.filter((l) => l);
  for (let i = 0; i < list.length; i++) {
    let line = list[i];
    //add # numberings formatting
    if (line.match(number_reg)) {
      line = line.replace(/^ ?#*/, number + ') ');
      line = line + '\n';
      number += 1;
    } else if (line.match(list_reg)) {
      number = 1;
      line = line.replace(list_reg, '');
    }
    list[i] = fromText(line);
  }
  return list
};

const grabList = function (lines, i) {
  let sub = [];
  for (let o = i; o < lines.length; o++) {
    if (isList(lines[o])) {
      sub.push(lines[o]);
    } else {
      break
    }
  }
  sub = sub.filter((a) => a && has_word.test(a));
  sub = cleanList(sub);
  return sub
};

const parseList = function (paragraph) {
  let wiki = paragraph.wiki;
  let lines = wiki.split(/\n/g);
  let lists = [];
  let theRest = [];
  for (let i = 0; i < lines.length; i++) {
    if (isList(lines[i])) {
      let sub = grabList(lines, i);
      if (sub.length > 0) {
        lists.push(sub);
        i += sub.length - 1;
      }
    } else {
      theRest.push(lines[i]);
    }
  }
  paragraph.lists = lists.map((l) => new List(l, wiki));
  paragraph.wiki = theRest.join('\n');
};

const twoNewLines = /\r?\n\r?\n/;

const parseParagraphs = function (section, doc) {
  let wiki = section._wiki;
  let paragraphs = wiki.split(twoNewLines);
  //don't create empty paragraphs
  paragraphs = paragraphs.filter((p) => p && p.trim().length > 0);
  paragraphs = paragraphs.map((str) => {
    let paragraph = {
      wiki: str,
      lists: [],
      sentences: [],
      images: [],
    };
    //parse the lists
    parseList(paragraph);
    //parse images
    parseImages(paragraph, doc);
    //parse the sentences
    byParagraph(paragraph);
    return new Paragraph(paragraph)
  });
  section._wiki = wiki;
  section._paragraphs = paragraphs;
};

const open = '{';
const close = '}';

//grab all first-level recursions of '{{...}}'
const findFlat = function (wiki) {
  let depth = 0;
  let list = [];
  let carry = [];
  for (let i = wiki.indexOf(open); i !== -1 && i < wiki.length; depth > 0 ? i++ : (i = wiki.indexOf(open, i + 1))) {
    let c = wiki[i];
    //open it
    if (c === open) {
      depth += 1;
    }
    //close it
    if (depth > 0) {
      if (c === close) {
        depth -= 1;
        if (depth === 0) {
          carry.push(c);
          let tmpl = carry.join('');
          carry = [];
          //last check
          if (/\{\{/.test(tmpl) && /\}\}/.test(tmpl)) {
            list.push(tmpl);
          }
          continue
        }
      }
      //require two '{{' to open it
      if (depth === 1 && c !== open && c !== close) {
        depth = 0;
        carry = [];
        continue
      }
      carry.push(c);
    }
  }
  return list
};

//get the name of the template
//templates are usually '{{name|stuff}}'
const getName = function (tmpl) {
  let name = null;
  //{{name|foo}}
  if (/^\{\{[^\n]+\|/.test(tmpl)) {
    name = (tmpl.match(/^\{\{(.+?)\|/) || [])[1];
  } else if (tmpl.indexOf('\n') !== -1) {
    // {{name \n...
    name = (tmpl.match(/^\{\{(.+)\n/) || [])[1];
  } else {
    //{{name here}}
    name = (tmpl.match(/^\{\{(.+?)\}\}$/) || [])[1];
  }
  if (name) {
    name = name.replace(/:.*/, '');
    name = fmtName(name);
  }
  return name || null
};

const hasTemplate$1 = /\{\{/;

const parseTemplate$1 = function (tmpl) {
  // this is some unexplained Lua thing
  return {
    body: tmpl,
    name: getName(tmpl),
    children: [],
  }
};

const doEach = function (obj) {
  // peel-off top-level
  let wiki = obj.body.substr(2);
  wiki = wiki.replace(/\}\}$/, '');

  // get our child templates
  obj.children = findFlat(wiki);
  obj.children = obj.children.map(parseTemplate$1);

  if (obj.children.length === 0) {
    return obj
  }
  // recurse through children
  obj.children.forEach((ch) => {
    let inside = ch.body.substr(2);
    if (hasTemplate$1.test(inside)) {
      return doEach(ch) //keep going
    }
    return null
  });
  return obj
};

// return a nested structure of all templates
const findTemplates = function (wiki) {
  let list = findFlat(wiki);
  list = list.map(parseTemplate$1);
  list = list.map(doEach);
  return list
};

//we explicitly ignore these, because they sometimes have resolve some data
const list = [
  //https://en.wikipedia.org/wiki/category:templates_with_no_visible_output
  'anchor',
  'defaultsort',
  'use list-defined references',
  'void',
  //https://en.wikipedia.org/wiki/Category:Protection_templates
  'pp',
  'pp-move-indef',
  'pp-semi-indef',
  'pp-vandalism',
  //out-of-scope still - https://en.wikipedia.org/wiki/Template:Tag
  '#tag',
  //https://en.wikipedia.org/wiki/Template:Navboxes
  // 'navboxes',
  // 'reflist',
  // 'ref-list',
  'div col',
  // 'authority control',
  //https://en.wikipedia.org/wiki/Template:End
  'pope list end',
  'shipwreck list end',
  'starbox end',
  'end box',
  'end',
  's-end',
];
const ignore = list.reduce((h, str) => {
  h[str] = true;
  return h
}, {});

var infoboxes = {
  'gnf protein box': true,
  'automatic taxobox': true,
  'chembox ': true,
  editnotice: true,
  geobox: true,
  hybridbox: true,
  ichnobox: true,
  infraspeciesbox: true,
  mycomorphbox: true,
  oobox: true,
  'paraphyletic group': true,
  speciesbox: true,
  subspeciesbox: true,
  'starbox short': true,
  taxobox: true,
  nhlteamseason: true,
  'asian games bid': true,
  'canadian federal election results': true,
  'dc thomson comic strip': true,
  'daytona 24 races': true,
  edencharacter: true,
  'moldova national football team results': true,
  samurai: true,
  protein: true,
  'sheet authority': true,
  'order-of-approx': true,
  'bacterial labs': true,
  'medical resources': true,
  ordination: true,
  'hockey team coach': true,
  'hockey team gm': true,
  'pro hockey team': true,
  'hockey team player': true,
  'hockey team start': true,
  mlbbioret: true,
};

const i18nReg = new RegExp('^(subst.)?(' + infoboxes$1.join('|') + ')(?=:| |\n|$)', 'i');
infoboxes$1.forEach(name => {
  infoboxes[name] = true;
});

//some looser ones
const startReg = /^infobox /i;
const endReg = / infobox$/i;
const yearIn = /^year in [A-Z]/i;

//some known ones from
//https://en.wikipedia.org/wiki/Wikipedia:List_of_infoboxes
//and https://en.wikipedia.org/wiki/Category:Infobox_templates
const isInfobox = function (name) {
  //known
  if (infoboxes.hasOwnProperty(name) === true) {
    return true
  }
  if (i18nReg.test(name)) {
    return true
  }
  if (startReg.test(name) || endReg.test(name)) {
    return true
  }
  //these are also infoboxes: 'Year in Belarus'
  if (yearIn.test(name)) {
    return true
  }
  return false
};

//turns template data into good infobox data
const fmtInfobox = function (obj = {}) {
  let m = obj.template.match(i18nReg);
  let type = obj.template;
  if (m && m[0]) {
    type = type.replace(m[0], '');
  }
  type = type.trim();
  let infobox = {
    template: 'infobox',
    type: type,
    data: obj,
  };
  delete infobox.data.template; //already have this.
  delete infobox.data.list; //just in case!
  return infobox
};

//aliases
let aliases = {
  imdb: 'imdb name',
  'imdb episodes': 'imdb episode',
  localday: 'currentday',
  localdayname: 'currentdayname',
  localyear: 'currentyear',
  'birth date based on age at death': 'birth based on age as of date',
  'bare anchored list': 'anchored list',
  cvt: 'convert',
  cricon: 'flagicon',
  sfrac: 'frac',
  sqrt: 'radic',
  'unreferenced section': 'unreferenced',
  redir: 'redirect',
  sisterlinks: 'sister project links',
  'main article': 'main',
  by: 'baseball year',
  aldsy: 'alds year',
  nldsy: 'nlds year',
  //not perfect..
  'str rep': 'replace',
  ushr2: 'ushr',
  stn: 'station',
  metrod: 'metro',
  fw: 'ferry',
  rws: 'stnlnk',
  sclass2: 'sclass',
  under: 'underline',
  brackets: 'bracket',
  raise: 'lower',
  'born-in': 'born in',
  'c.': 'circa',
  'r.': 'reign',
  frac: 'fraction',
  rdelim: 'ldelim',
  abs: 'pipe',
  'pp.': 'p.',
  'iss.': 'vol.',
  h2d: 'hex2dec',
};

//multiple aliases
let multi = {
  date: ['byline', 'dateline'], //wikinews
  citation: ['cite', 'source', 'source-pr', 'source-science'],

  'no spam': ['email', '@', 'no spam blue'],
  'angle bracket': ['angbr', 'infix', 'angbr ipa'],

  'lrt station': ['lrt', 'lrts'],
  'mrt station': ['mrt', 'mrts'],

  flagcountry: ['cr', 'cr-rt'],

  trunc: ['str left', 'str crop'],

  percentage: ['pct', 'percentage'],

  rnd: ['rndfrac', 'rndnear'],

  abbr: ['tooltip', 'abbrv', 'define'],

  sfn: ['sfnref', 'harvid', 'harvnb'],

  'birth date and age': ['death date and age', 'bda', 'b-da'],

  currentmonth: ['localmonth', 'currentmonthname', 'currentmonthabbrev'],

  currency: ['monnaie', 'unité', 'nombre', 'nb', 'iso4217'],

  coord: ['coor', 'coor title dms', 'coor title dec', 'coor dms', 'coor dm', 'coor dec'],

  'columns-list': ['cmn', 'col-list', 'columnslist', 'collist'],

  nihongo: ['nihongo2', 'nihongo3', 'nihongo-s', 'nihongo foot'],

  plainlist: ['flatlist', 'plain list'],

  'winning percentage': ['winpct', 'winperc'],

  'collapsible list': [
    'nblist',
    'nonbulleted list',
    'ubl',
    'ublist',
    'ubt',
    'unbullet',
    'unbulleted list',
    'unbulleted',
    'unbulletedlist',
    'vunblist',
  ],

  'election box begin': [
    'election box begin no change',
    'election box begin no party',
    'election box begin no party no change',
    'election box inline begin',
    'election box inline begin no change',
  ],

  'election box candidate': [
    'election box candidate for alliance',
    'election box candidate minor party',
    'election box candidate no party link no change',
    'election box candidate with party link',
    'election box candidate with party link coalition 1918',
    'election box candidate with party link no change',
    'election box inline candidate',
    'election box inline candidate no change',
    'election box inline candidate with party link',
    'election box inline candidate with party link no change',
    'election box inline incumbent',
  ],

  '4teambracket': [
    '2teambracket',
    '4team2elimbracket',
    '8teambracket',
    '16teambracket',
    '32teambracket',
    '4roundbracket-byes',
    'cwsbracket',
    'nhlbracket',
    'nhlbracket-reseed',
    '4teambracket-nhl',
    '4teambracket-ncaa',
    '4teambracket-mma',
    '4teambracket-mlb',
    '16teambracket-two-reseeds',
    '8teambracket-nhl',
    '8teambracket-mlb',
    '8teambracket-ncaa',
    '8teambracket-afc',
    '8teambracket-afl',
    '8teambracket-tennis3',
    '8teambracket-tennis5',
    '16teambracket-nhl',
    '16teambracket-nhl divisional',
    '16teambracket-nhl-reseed',
    '16teambracket-nba',
    '16teambracket-swtc',
    '16teambracket-afc',
    '16teambracket-tennis3',
    '16teambracket-tennis5',
  ],

  start: [
    'end',
    'birth',
    'death',
    'start date',
    'end date',
    'birth date',
    'birthdate',
    'death date',
    'start date and age',
    'end date and age',
    'dob',
  ],

  'start-date': [
    'end-date',
    'birth-date',
    'death-date',
    'birth-date and age',
    'birth-date and given age',
    'death-date and age',
    'death-date and given age',
  ],

  tl: [
    'lts',
    't',
    'tfd links',
    'tiw',
    'tltt',
    'tetl',
    'tsetl',
    'ti',
    'tic',
    'tiw',
    'tlt',
    'ttl',
    'twlh',
    'tl2',
    'tlu',
    'demo',
    'xpd',
    'para',
    'elc',
    'xtag',
    'mli',
    'mlix',
    'url', //https://en.wikipedia.org/wiki/Template:URL
  ],

  // https://en.wikipedia.org/wiki/Template:Done/See_also
  done: [
    'resolved mark large',
    'implemented',
    'pimplemented',
    'resolved mark',
    'accepted',
    'agree',
    'approved',
    'checked2',
    'verified',
    'conditional yes',
    'confirmed',
    'confirmed-nc',
    'tallyho',
    'tick',
    'helped',
    'doneu|example',
    'edited2',
    'donetask',
    'unprod',
    'autp',
    'responded',
    'sure',
    'merge done',
    'marked',
    'pass',
    'aye',
    'yes check',
    'y&',
    'yeac',
    'yeag',
  ],
  xmark: [
    'expired',
    'deleted',
    'not done',
    'not done empty request',
    'not done unclear',
    'not done not likely',
    'stale-small',
    'smallrejected',
    'x mark',
    'nay',
    'no mark',
    'not done-t',
    'fail',
    'n&',
    'x mark-n',
    'xed box',
    'cancelled',
    'deleted-image',
    'already declined',
    'opblocked',
    'user-blocked',
    'notabug',
    'notfixed',
    "won't fix",
    'withdraw',
    'nojoy',
    'unrelated',
    'off-topic talk',
    'nayc',
    'nayg',
  ],
  checked: ['already done', 'resolved1', 'check mark-n', 'checked box'],
  // https://en.wikipedia.org/wiki/Template:Ferry
  'station link': ['amtk', 'cta', 'bts', 'mnrr', 'mtams', 'munis', 'njts', 'scax', 'wmata', 'rwsa'],
  'video game release': ['vgrelease', 'video game release hlist', 'vgrtbl', 'vgrelease hlist', 'vgrh'],
  aka: ['a.k.a.', 'also known as'],
  'literal translation': ['lit', 'literal', 'literally'],
  'citation needed': [
    'are you sure?',
    'cb',
    'ciation needed',
    'cit',
    'cita requerida',
    'citaiton needed',
    'citation missing',
    'citation need',
    'citation requested',
    'citation required',
    'citation-needed',
    'citationeeded',
    'citationneeded',
    'citationrequired',
    'citazione necessaria',
    'cite missing',
    'cite needed',
    'cite source',
    'cite-needed',
    'citeneeded',
    'citesource',
    'citn',
    'cn needed',
    'cn',
    'ctn',
    'fact?',
    'fact',
    'facts',
    'fcitation needed',
    'me-fact',
    'need citation',
    'need sources',
    'need-ref',
    'needcitation',
    'needcite',
    'needs citation',
    'needs citations',
    'needs reference',
    'needs source',
    'needs-cite',
    'needsref',
    'no source given',
    'prov-statement',
    'prove it',
    'proveit',
    'ref needed',
    'ref-needed',
    'ref?',
    'reference necessary',
    'reference needed',
    'reference required',
    'refnec',
    'refneeded',
    'refplease',
    'request citation',
    'source needed',
    'source?',
    'sourceme',
    'uncited',
    'unreferenced inline',
    'unsourced-inline',
  ],

  'en dash': ['ndash', 'nsndns'],
  'spaced en dash': ['spnd', 'sndash', 'spndash'],
  'spaced en dash space': ['snds', 'spndsp', 'sndashs', 'spndashsp'],
  'zero width joiner em dash zero width non joiner': ['nsmdns', 'nsmdashns', 'nsemdashns', 'mdashb'],
  color: ['colour', 'colored text', 'fgcolor'],
};

// - other languages -
// Polish, {{IPAc-pl}}	{{IPAc-pl|'|sz|cz|e|ć|i|n}} → [ˈʂt͡ʂɛt͡ɕin]
// Portuguese, {{IPAc-pt}}	{{IPAc-pt|p|o|<|r|t|u|'|g|a|l|lang=pt}} and {{IPAc-pt|b|r|a|'|s|i|l|lang=br}} → [puɾtuˈɣaɫ] and [bɾaˈsiw]
Object.keys(languages).forEach((lang) => {
  aliases['ipa-' + lang] = 'ipa';
  aliases['ipac-' + lang] = 'ipac';
});

// add each alias in
Object.keys(multi).forEach((k) => {
  multi[k].forEach((str) => {
    aliases[str] = k;
  });
});

var hardcoded = {
  '·': '·',
  dot: '·',
  middot: '·',
  '•': ' • ',
  ',': ',',
  '=': '=',
  '1/2': '1⁄2',
  '1/3': '1⁄3',
  '2/3': '2⁄3',
  '1/4': '1⁄4',
  '3/4': '3⁄4',
  '–': '–',
  ndash: '–',
  'en dash': '–',
  'spaced ndash': ' – ',
  '—': '—',
  mdash: '—',
  spd: ' – ',
  'em dash': '—',
  'number sign': '#',
  'hash-tag': '#',
  ibeam: 'I',
  '&': '&',
  ';': ';',
  ampersand: '&',
  dagger: '†',
  'double-dagger': '‡',
  snds: ' – ',
  snd: ' – ',
  '^': ' ',
  '!': '|',
  "'": `'`,
  '\\': ' /',
  '`': '`',
  // bracket: '[',
  '[': '[',
  '*': '*',
  asterisk: '*',
  'long dash': '———',
  clear: '\n\n',
  'h.': 'ḥ',
  profit: '▲',
  // loss: '▼',
  // gain: '▲',
  ell: 'ℓ',
  '1~': '~',
  '2~': '~~',
  '3~': '~~~',
  '4~': '~~~~',
  '5~': '~~~~~',
  // some emoji replacements
  goldmedal: '🥇',
  silvermedal: '🥈',
  bronzemedal: '🥉',
  done: '✅',
  xmark: '❌',
  checked: '✔️',
  'thumbs up': '👍',
  'thumbs down': '👎',
  minusplus: '∓',
  plusminus: '±',

  // 'hbeff début': '{|-\n',
  egiptekas: '{|-\n',
  langle: '⟨',
  rangle: '⟩',
  epsilon: 'ε',
  xi: '𝜉',
  Φ: 'Φ',
  phi: '𝜙',
  varphi: '𝜑',
  upsilon: '𝜐',
  tau: '𝜏',
  varsigma: '𝜍',
  sigma: '𝜎',
  pi: 'π',
  mu: '𝜇',
  lambda: '𝜆',
  kappa: '𝜘',
  vartheta: '𝜗',
  theta: '𝜃',
  varepsilon: '𝜀',
  gamma: '𝛾',
  shy: '-',
  mdashb: '—‌',
  'spaced en dash': ' –',
  'spaced en dash space': ' – ',
  'zero width joiner em dash zero width non joiner': '—‌',
  colon: ':',
  pipe: '|',
  '-?': '?',
  zwsp: ' ',
  sp: ' ',
  px2: ' ',
  indent: '    ',
  nb5: '    ',
  ns: '    ',
  quad: '    ',
  spaces: '    ',
  in5: '     ',
  tombstone: '◻',
  // increase: '▲',
  // decrease: '▼',
  'no.': '#',
  'thin space': ' ',
  thinspace: ' ',
  'very thin space': ' ',
  'word joiner': ' ',
  'figure space': ' ',
  'zero width joiner': ' ',
  'hair space': ' ',
  'narrow no-break space': ' ',
  'non breaking hyphen': '-',
  '!((': '[[',
  '))!': ']]',
  '(': '{',
  '((': '{{',
  '(((': '{{{',
  ')': '}',
  '))': '}}',
  ')))': '}}}',
  '(!': '{|',
  '!+': '|+',
  '!-': '|-',
  '!)': '|}',
  flat: '♭',
  sharp: '♯',
  lbf: 'lbF',
  lbm: 'lbm',
};

//grab the first, second or third pipe..
let templates$c = {
  p1: 0,
  p2: 1,
  p3: 2,
  resize: 1, //https://en.wikipedia.org/wiki/'Resize',
  lang: 1,
  'rtl-lang': 1,
  'line-height': 1,
  l: 2,
  h: 1, //https://en.wikipedia.org/wiki/'Hover_title',
  sort: 1, //https://en.wikipedia.org/wiki/'Sort',
  color: 1,
  'background color': 1,
};

//templates that we simply grab their insides as plaintext
let zeros = [
  'defn',
  'lino', //https://en.wikipedia.org/wiki/'Linum',
  'finedetail', //https://en.wikipedia.org/wiki/'Finedetail',
  'nobold',
  'noitalic',
  'nocaps',
  'vanchor', //https://en.wikipedia.org/wiki/'Visible_anchor',
  'rnd',
  'date', //Explictly-set dates - https://en.wikipedia.org/wiki/'Date',
  'taste',
  'monthname',
  'baseball secondary style',
  'nowrap',
  'nobr',
  'big',
  'cquote',
  'pull quote',
  'smaller',
  'midsize',
  'larger',
  'big',
  'kbd',
  'bigger',
  'large',
  'mono',
  'strongbad',
  'stronggood',
  'huge',
  'xt',
  'xt2',
  '!xt',
  'xtn',
  'xtd',
  'dc',
  'dcr',
  'mxt',
  '!mxt',
  'mxtn',
  'mxtd',
  'bxt',
  '!bxt',
  'bxtn',
  'bxtd',
  'delink', //https://en.wikipedia.org/wiki/'Delink',
  'pre',
  'var',
  'mvar',
  'pre2',
  'code',
  'char',
  'angle bracket',
  'symb',
  'dabsearch',
  'key press', //needs work - https://en.m.wikipedia.org/wiki/'Key_press',
  // these should escape certain chars
  'nowiki',
  'nowiki2',
  'unstrip',
  'unstripnowiki',
  'plain text',
  'make code',
  'killmarkers',
  'longitem',
  'longlink',
  'strikethrough',
  'underline',
  'uuline',
  'not a typo',
  'text',
  'var serif',
  'double underline',
  'nee',
  'ne',
  'left',
  'right',
  'center',
  'centered',
  'justify',
  'smalldiv',
  'bold div',
  'monodiv',
  'italic div',
  'bigdiv',
  'strikethroughdiv',
  'strikethrough color',
  'pbpe', //pt
  'video game release/abbr',
  'nobel abbr',
  'gloss',
  'gcl',
  'overline',
  'underline',
  'overarc',
  'normal',
  'norm',
  'tmath',
  'vec',
  'subst',
  'highlight',
  'tq',
  'subst:nft',
  'subst:nwft',
  'subst:nfa',
];
zeros.forEach((k) => {
  templates$c[k] = 0;
});

let templates$b = {};
// these templates all have a predictable pattern
// {{HSC|Ship Name|ID}} -> [[HSC Name (id)]]
let arr = [
  // ships
  'mv',
  'm/v',
  'gts',
  'hsc',
  'ms',
  'm/s',
  'my',
  'm/y',
  'ps',
  'rms',
  'rv',
  'r/v',
  'sb',
  'ss',
  's/s',
  'sv',
  's/v',
  'sy',
  's/y',
  'tss',
  'ans',
  'hmas',
  'hmbs',
  'bns',
  'hmcs',
  'ccgs',
  'arc',
  'hdms',
  'bae',
  'ens',
  'eml',
  'rfns',
  'fns',
  'hs',
  'sms',
  'smu',
  'gs',
  'icgv',
  'ins',
  'kri',
  'lé',
  'jsub',
  'jds',
  'js',
  'hnlms',
  'hmnzs',
  'nns',
  'hnoms',
  'hmpngs',
  'bap',
  'rps',
  'brp',
  'orp',
  'nrp',
  'nms',
  'rss',
  'sas',
  'hmsas',
  'roks',
  'hswms',
  'htms',
  'tcg',
  'hms',
  'hmt',
  'rfaux',
  'usat',
  'uscgc',
  'usns',
  'usrc',
  'uss',
  'usav',
];

arr.forEach((word) => {
  templates$b[word] = (tmpl) => {
    let { name, id } = parser(tmpl, ['name', 'id']);
    return id ? `[[${word.toUpperCase()} ${name} (${id})]]` : `[[${word.toUpperCase()} ${name}]]`
  };
});

let links = ['no redirect', 'tl-r', 'template link no redirect', 'redirect?', 'subatomic particle', 'auto link', 'bl'];
links.forEach((word) => {
  templates$b[word] = (tmpl) => {
    let data = parser(tmpl, ['page', 'text']);
    if (data.text && data.text !== data.page) {
      return `[[${data.page}|${data.text}]]`
    }
    return `[[${data.page}]]`
  };
});

//simply num/denom * 100
const percentage = function (obj) {
  if (!obj.numerator && !obj.denominator) {
    return null
  }
  let perc = Number(obj.numerator) / Number(obj.denominator);
  perc *= 100;
  Number(obj.decimals);
  return parseInt(perc, 10)
};

const toNumber = function (str = '') {
  if (typeof str === 'number') {
    return str
  }
  str = str.replace(/,/g, '');
  str = str.replace(/−/g, '-');
  let num = Number(str);
  if (isNaN(num)) {
    return str
  }
  return num
};

const getLang = function (name) {
  //grab the language from the template name - 'ipa-de'
  let lang = name.match(/ipac?-(.+)/);
  if (lang !== null) {
    if (languages.hasOwnProperty(lang[1]) === true) {
      return languages[lang[1]].english_title
    }
    return lang[1]
  }
  return null
};

const titlecase = (str) => {
  return str.charAt(0).toUpperCase() + str.substring(1)
};

const toOrdinal = function (i) {
  let j = i % 10;
  let k = i % 100;
  if (j === 1 && k !== 11) {
    return i + 'st'
  }
  if (j === 2 && k !== 12) {
    return i + 'nd'
  }
  if (j === 3 && k !== 13) {
    return i + 'rd'
  }
  return i + 'th'
};

const sisterProjects = {
  wikt: 'wiktionary',
  commons: 'commons',
  c: 'commons',
  commonscat: 'commonscat',
  n: 'wikinews',
  q: 'wikiquote',
  s: 'wikisource',
  a: 'wikiauthor',
  b: 'wikibooks',
  voy: 'wikivoyage',
  v: 'wikiversity',
  d: 'wikidata',
  species: 'wikispecies',
  m: 'meta',
  mw: 'mediawiki',
};

var functions = {
  //https://en.wikipedia.org/wiki/Template:Ra
  ra: (tmpl) => {
    let obj = parser(tmpl, ['hours', 'minutes', 'seconds']);
    return [obj.hours || 0, obj.minutes || 0, obj.seconds || 0].join(':')
  },

  //https://en.wikipedia.org/wiki/Template:Deg2HMS
  deg2hms: (tmpl) => {
    //this template should do the conversion
    let obj = parser(tmpl, ['degrees']);
    return (obj.degrees || '') + '°'
  },

  hms2deg: (tmpl) => {
    //this template should do the conversion too
    let obj = parser(tmpl, ['hours', 'minutes', 'seconds']);
    return [obj.hours || 0, obj.minutes || 0, obj.seconds || 0].join(':')
  },

  decdeg: (tmpl) => {
    //this template should do the conversion too
    let obj = parser(tmpl, ['deg', 'min', 'sec', 'hem', 'rnd']);
    return (obj.deg || obj.degrees) + '°'
  },
  //https://en.wikipedia.org/wiki/Template:Sortname
  sortname: (tmpl) => {
    let obj = parser(tmpl, ['first', 'last', 'target', 'sort']);
    let name = `${obj.first || ''} ${obj.last || ''}`;
    name = name.trim();
    if (obj.nolink) {
      return obj.target || name
    }
    if (obj.dab) {
      name += ` (${obj.dab})`;
      if (obj.target) {
        obj.target += ` (${obj.dab})`;
      }
    }
    if (obj.target) {
      return `[[${obj.target}|${name}]]`
    }
    return `[[${name}]]`
  },

  // https://en.wikipedia.org/wiki/Template:First_word
  'first word': (tmpl) => {
    let obj = parser(tmpl, ['text']);
    let str = obj.text || '';
    if (obj.sep) {
      return str.split(obj.sep)[0]
    }
    return str.split(' ')[0]
  },

  trunc: (tmpl) => {
    let obj = parser(tmpl, ['str', 'len']);
    return (obj.str || '').substr(0, obj.len)
  },

  'str mid': (tmpl) => {
    let obj = parser(tmpl, ['str', 'start', 'end']) || {};
    let start = parseInt(obj.start, 10) - 1;
    let end = parseInt(obj.end, 10);
    return (obj.str || '').substr(start, end)
  },

  reign: (tmpl) => {
    let obj = parser(tmpl, ['start', 'end']);
    return `(r. ${obj.start} – ${obj.end})`
  },

  // https://en.wikipedia.org/wiki/Template:Decade_link
  'decade link': (tmpl) => {
    let { year } = parser(tmpl, ['year']);
    return `${year}|${year}s`
  },

  // https://en.wikipedia.org/wiki/Template:Decade
  decade: (tmpl) => {
    let obj = parser(tmpl, ['year']);
    let year = Number(obj.year);
    year = Math.floor(year / 10) * 10; // round to decade
    return `${year}s`
  },

  // https://en.wikipedia.org/wiki/Template:Century
  century: (tmpl) => {
    let obj = parser(tmpl, ['year']);
    let year = parseInt(obj.year, 10);
    year = Math.floor(year / 100) + 1;
    return `${year}`
  },

  //https://en.wikipedia.org/wiki/Template:Radic
  radic: (tmpl) => {
    let obj = parser(tmpl, ['after', 'before']);
    return `${obj.before || ''}√${obj.after || ''}`
  },

  'medical cases chart/row': (tmpl) => {
    // Deprecated template; we keep it.
    return tmpl
  },

  //https://en.wikipedia.org/wiki/Template:OldStyleDate
  oldstyledate: (tmpl) => {
    let obj = parser(tmpl, ['date', 'year']);
    return obj.year ? obj.date + ' ' + obj.year : obj.date
  },

  //formatting things - https://en.wikipedia.org/wiki/Template:Nobold
  braces: (tmpl) => {
    let obj = parser(tmpl, ['text']);
    let attrs = '';
    if (obj.list) {
      attrs = '|' + obj.list.join('|');
    }
    return '{{' + (obj.text || '') + attrs + '}}'
  },

  hlist: (tmpl) => {
    let obj = parser(tmpl);
    obj.list = obj.list || [];
    return obj.list.join(' · ')
  },

  pagelist: (tmpl) => {
    let arr = parser(tmpl).list || [];
    return arr.join(', ')
  },

  // not perfect - https://en.m.wikipedia.org/wiki/Template:Interlinear
  interlinear: (tmpl) => {
    let arr = parser(tmpl).list || [];
    return arr.join('\n\n')
  },

  //actually rendering these links removes the text.
  //https://en.wikipedia.org/wiki/Template:Catlist
  catlist: (tmpl) => {
    let arr = parser(tmpl).list || [];
    return arr.join(', ')
  },

  //https://en.wikipedia.org/wiki/Template:Br_separated_entries
  'br separated entries': (tmpl) => {
    let arr = parser(tmpl).list || [];
    return arr.join('\n\n')
  },

  'comma separated entries': (tmpl) => {
    let arr = parser(tmpl).list || [];
    return arr.join(', ')
  },

  //https://en.wikipedia.org/wiki/Template:Bare_anchored_list
  'anchored list': (tmpl) => {
    let arr = parser(tmpl).list || [];
    arr = arr.map((str, i) => `${i + 1}. ${str}`);
    return arr.join('\n\n')
  },

  'bulleted list': (tmpl) => {
    let arr = parser(tmpl).list || [];
    arr = arr.filter((f) => f);
    arr = arr.map((str) => '• ' + str);
    return arr.join('\n\n')
  },

  //a strange, newline-based list - https://en.wikipedia.org/wiki/Template:Plainlist
  plainlist: (tmpl) => {
    tmpl = strip(tmpl);
    let arr = tmpl.split('|').slice(1); //remove the title
    arr = arr.join('|').split(/\n ?\* ?/); //split on newline
    arr = arr.filter((s) => s);
    return arr.join('\n\n')
  },

  //https://en.wikipedia.org/wiki/Template:Term
  term: (tmpl) => {
    let obj = parser(tmpl, ['term']);
    return `${obj.term}:`
  },

  linum: (tmpl) => {
    let { num, text } = parser(tmpl, ['num', 'text']);
    return `${num}. ${text}`
  },

  'block indent': (tmpl) => {
    let obj = parser(tmpl);
    if (obj['1']) {
      return '\n' + obj['1'] + '\n'
    }
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Lbs
  lbs: (tmpl) => {
    let obj = parser(tmpl, ['text']);
    return `[[${obj.text} Lifeboat Station|${obj.text}]]`
  },

  //Foo-class
  lbc: (tmpl) => {
    let obj = parser(tmpl, ['text']);
    return `[[${obj.text}-class lifeboat|${obj.text}-class]]`
  },

  lbb: (tmpl) => {
    let obj = parser(tmpl, ['text']);
    return `[[${obj.text}-class lifeboat|${obj.text}]]`
  },

  //https://www.mediawiki.org/wiki/Help:Magic_words#Formatting
  '#dateformat': (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let obj = parser(tmpl, ['date', 'format']);
    return obj.date
  },

  //https://www.mediawiki.org/wiki/Help:Magic_words#Formatting
  lc: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let obj = parser(tmpl, ['text']);
    return (obj.text || '').toLowerCase()
  },

  //https://www.mediawiki.org/wiki/Help:Magic_words#Formatting
  uc: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let obj = parser(tmpl, ['text']);
    return (obj.text || '').toUpperCase()
  },

  lcfirst: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let text = parser(tmpl, ['text']).text;
    if (!text) {
      return ''
    }
    return text[0].toLowerCase() + text.substr(1)
  },

  ucfirst: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let text = parser(tmpl, ['text']).text;
    if (!text) {
      return ''
    }
    return text[0].toUpperCase() + text.substr(1)
  },

  padleft: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let obj = parser(tmpl, ['text', 'num']);
    let text = obj.text || '';
    return text.padStart(obj.num, obj.str || '0')
  },

  padright: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let obj = parser(tmpl, ['text', 'num']);
    let text = obj.text || '';
    return text.padEnd(obj.num, obj.str || '0')
  },

  //https://en.wikipedia.org/wiki/Template:Abbrlink
  abbrlink: (tmpl) => {
    let obj = parser(tmpl, ['abbr', 'page']);
    if (obj.page) {
      return `[[${obj.page}|${obj.abbr}]]`
    }
    return `[[${obj.abbr}]]`
  },

  // https://en.wikipedia.org/wiki/Template:Own
  own: (tmpl) => {
    let obj = parser(tmpl, ['author']);
    let str = 'Own work';
    if (obj.author) {
      str += ' by ' + obj.author;
    }
    return str
  },

  //https://www.mediawiki.org/wiki/Help:Magic_words#Formatting
  formatnum: (tmpl) => {
    tmpl = tmpl.replace(/:/, '|');
    let obj = parser(tmpl, ['number']);
    let str = obj.number || '';
    str = str.replace(/,/g, '');
    let num = Number(str);
    return num.toLocaleString() || ''
  },

  //https://en.wikipedia.org/wiki/Template:Frac
  fraction: (tmpl) => {
    let obj = parser(tmpl, ['a', 'b', 'c']);
    if (obj.c) {
      return `${obj.a} ${obj.b}/${obj.c}`
    }
    if (obj.b) {
      return `${obj.a}/${obj.b}`
    }
    return `1/${obj.b}`
  },

  //https://en.wikipedia.org/wiki/Template:Convert#Ranges_of_values
  convert: (tmpl) => {
    let obj = parser(tmpl, ['num', 'two', 'three', 'four']);
    //todo: support plural units
    if (obj.two === '-' || obj.two === 'to' || obj.two === 'and') {
      if (obj.four) {
        return `${obj.num} ${obj.two} ${obj.three} ${obj.four}`
      }
      return `${obj.num} ${obj.two} ${obj.three}`
    }
    return `${obj.num} ${obj.two}`
  },

  // Large number of aliases - https://en.wikipedia.org/wiki/Template:Tl
  tl: (tmpl) => {
    let obj = parser(tmpl, ['first', 'second']);
    return obj.second || obj.first
  },

  //this one's a little different
  won: (tmpl) => {
    let data = parser(tmpl, ['text']);
    return data.place || data.text || titlecase(data.template)
  },

  //a convulated way to make a xml tag - https://en.wikipedia.org/wiki/Template:Tag
  tag: (tmpl) => {
    let obj = parser(tmpl, ['tag', 'open']);
    const ignore = {
      span: true,
      div: true,
      p: true,
    };
    //pair, empty, close, single
    if (!obj.open || obj.open === 'pair') {
      //just skip generating spans and things..
      if (ignore[obj.tag]) {
        return obj.content || ''
      }
      return `<${obj.tag} ${obj.attribs || ''}>${obj.content || ''}</${obj.tag}>`
    }
    return ''
  },

  //dumb inflector - https://en.wikipedia.org/wiki/Template:Plural
  plural: (tmpl) => {
    tmpl = tmpl.replace(/plural:/, 'plural|');
    let obj = parser(tmpl, ['num', 'word']);
    let num = Number(obj.num);
    let word = obj.word;
    if (num !== 1) {
      if (/.y$/.test(word)) {
        word = word.replace(/y$/, 'ies');
      } else {
        word += 's';
      }
    }
    return num + ' ' + word
  },

  //https://en.wikipedia.org/wiki/Template:DEC
  dec: (tmpl) => {
    let obj = parser(tmpl, ['degrees', 'minutes', 'seconds']);
    let str = (obj.degrees || 0) + '°';
    if (obj.minutes) {
      str += obj.minutes + `′`;
    }
    if (obj.seconds) {
      str += obj.seconds + '″';
    }
    return str
  },

  //https://en.wikipedia.org/wiki/Template:Val
  val: (tmpl) => {
    let obj = parser(tmpl, ['number', 'uncertainty']);
    let num = obj.number;
    if (num && Number(num)) {
      num = Number(num).toLocaleString();
    }
    let str = num || '';
    //prefix/suffix
    if (obj.p) {
      str = obj.p + str;
    }
    if (obj.s) {
      str = obj.s + str;
    }
    //add units, too
    if (obj.u || obj.ul || obj.upl) {
      str = str + ' ' + (obj.u || obj.ul || obj.upl);
    }
    return str
  },

  //{{percentage | numerator | denominator | decimals to round to (zero or greater) }}
  percentage: (tmpl) => {
    let obj = parser(tmpl, ['numerator', 'denominator', 'decimals']);
    let num = Number(obj.numerator) / Number(obj.denominator);
    num *= 100;
    if (num === null) {
      return ''
    }
    let dec = Number(obj.decimals) || 0;
    return `${num.toFixed(dec)}%`
  },
  // this one is re-used by i18n
  small: (tmpl) => {
    let obj = parser(tmpl);
    if (obj.list && obj.list[0]) {
      return obj.list[0]
    }
    return ''
  },

  // {{Percent-done|done=N|total=N|digits=N}}
  'percent-done': (tmpl) => {
    let obj = parser(tmpl, ['done', 'total', 'digits']);
    let num = percentage({
      numerator: obj.done,
      denominator: obj.total,
      decimals: obj.digits,
    });
    if (num === null) {
      return ''
    }
    return `${obj.done} (${num}%) done`
  },

  loop: (tmpl) => {
    let data = parser(tmpl, ['times', 'text']);
    let n = Number(data.times) || 0;
    let out = '';
    for (let i = 0; i < n; i += 1) {
      out += data.text || '';
    }
    return out
  },
  'str len': (tmpl) => {
    let data = parser(tmpl, ['text']);
    return String((data.text || '').trim().length)
  },
  digits: (tmpl) => {
    let data = parser(tmpl, ['text']);
    return (data.text || '').replace(/[^0-9]/g, '')
  },
  resize: (tmpl) => {
    let { n, text } = parser(tmpl, ['n', 'text']);
    if (!text) {
      return n || ''
    }
    return text || ''
  },
  'last word': (tmpl) => {
    let data = parser(tmpl, ['text']);
    let arr = (data.text || '').split(/ /g);
    return arr[arr.length - 1] || ''
  },
  replace: (tmpl) => {
    let data = parser(tmpl, ['text', 'from', 'to']);
    if (!data.from || !data.to) {
      return data.text || ''
    }
    return (data.text || '').replace(data.from, data.to)
  },
  'title case': (tmpl) => {
    let data = parser(tmpl, ['text']);
    let txt = data.text || '';
    return txt
      .split(/ /)
      .map((w, i) => {
        if ((i > 0 && w === 'the') || w === 'of') {
          return w
        }
        return titlecase(w)
      })
      .join(' ')
  },
  'no spam': (tmpl) => {
    let data = parser(tmpl, ['account', 'domain']);
    return `${data.account || ''}@${data.domain}`
  },
  'baseball year': (tmpl) => {
    let year = parser(tmpl, ['year']).year || '';
    return `[[${year} in baseball|${year}]]`
  },
  'mlb year': (tmpl) => {
    let year = parser(tmpl, ['year']).year || '';
    return `[[${year} Major League Baseball season|${year}]]`
  },
  'nlds year': (tmpl) => {
    let { year } = parser(tmpl, ['year']);
    return `[[${year || ''} National League Division Series|${year}]]`
  },
  'alds year': (tmpl) => {
    let { year } = parser(tmpl, ['year']);
    return `[[${year || ''} American League Division Series|${year}]]`
  },
  'nfl year': (tmpl) => {
    let { year, other } = parser(tmpl, ['year', 'other']);
    if (other && year) {
      return `[[${year} NFL season|${year}]]–[[${other} NFL season|${other}]]`
    }
    return `[[${year || ''} NFL season|${year}]]`
  },
  'nfl playoff year': (tmpl) => {
    let { year } = parser(tmpl, ['year']);
    year = Number(year);
    let after = year + 1;
    return `[[${year}–${after} NFL playoffs|${year}]]`
  },
  'nba year': (tmpl) => {
    let { year } = parser(tmpl, ['year']);
    year = Number(year);
    let after = year + 1;
    return `[[${year}–${after} NBA season|${year}–${after}]]`
  },
  'mhl year': (tmpl) => {
    let data = parser(tmpl, ['year']);
    let year = Number(data.year);
    let after = year + 1;
    return `[[${year}–${after} NHL season|${year}–${after}]]`
  },
  // some math
  min: (tmpl) => {
    let arr = parser(tmpl).list || [];
    let min = Number(arr[0]) || 0;
    arr.forEach((str) => {
      let n = Number(str);
      if (!isNaN(n) && n < min) {
        min = n;
      }
    });
    return String(min)
  },
  max: (tmpl) => {
    let arr = parser(tmpl).list || [];
    let max = Number(arr[0]) || 0;
    arr.forEach((str) => {
      let n = Number(str);
      if (!isNaN(n) && n > max) {
        max = n;
      }
    });
    return String(max)
  },
  // US-politics
  uspolabbr: (tmpl) => {
    let { party, state, house } = parser(tmpl, ['party', 'state', 'house', 'link']);
    if (!party || !state) {
      return ''
    }
    let out = `${party}‑${state}`;
    if (house) {
      out += ` ${toOrdinal(house)}`;
    }
    return out
  },
  // https://en.wikipedia.org/wiki/Template:Ushr
  ushr: (tmpl) => {
    let { state, num, type } = parser(tmpl, ['state', 'num', 'type']);
    let link = '';
    if (num === 'AL') {
      link = `${state}'s at-large congressional district`;
    } else {
      num = toOrdinal(Number(num));
      return `${state}'s ${num} congressional district`
    }
    if (type) {
      type = type.toLowerCase();
      num = num === 'AL' ? 'At-large' : num;
      // there are many of these
      if (type === 'e') {
        return `[[${link}|${num}]]`
      }
      if (type === 'u') {
        return `[[${link}|${state}]]`
      }
      if (type === 'b' || type === 'x') {
        return `[[${link}|${state} ${num}]]`
      }
    }
    return `[[${link}]]`
  },

  // transit station links
  metro: (tmpl) => {
    let { name, dab } = parser(tmpl, ['name', 'dab']);
    if (dab) {
      return `[[${name} station (${dab})|${name}]]`
    }
    return `[[${name} station|${name}]]`
  },
  station: (tmpl) => {
    let { name, dab } = parser(tmpl, ['name', 'x', 'dab']);
    if (dab) {
      return `[[${name} station (${dab})|${name}]]`
    }
    return `[[${name} station|${name}]]`
  },
  bssrws: (tmpl) => {
    let { one, two } = parser(tmpl, ['one', 'two']);
    let name = one;
    if (two) {
      name += ' ' + two;
    }
    return `[[${name} railway station|${name}]]`
  },
  stnlnk: (tmpl) => {
    let { name, dab } = parser(tmpl, ['name', 'dab']);
    if (dab) {
      return `[[${name} railway station (${dab})|${name}]]`
    }
    return `[[${name} railway station|${name}]]`
  },
  // https://en.wikipedia.org/wiki/Template:Station_link
  'station link': (tmpl) => {
    let { station, system } = parser(tmpl, ['system', 'station']); //incomplete
    return station || system
  },
  'line link': (tmpl) => {
    let { station, system } = parser(tmpl, ['system', 'station']); //incomplete
    return station || system
  },
  subway: (tmpl) => {
    let { name } = parser(tmpl, ['name']);
    return `[[${name} subway station|${name}]]`
  },
  'lrt station': (tmpl) => {
    let { name } = parser(tmpl, ['name']);
    return `[[${name} LRT station|${name}]]`
  },
  'mrt station': (tmpl) => {
    let { name } = parser(tmpl, ['name']);
    return `[[${name} MRT station|${name}]]`
  },
  rht: (tmpl) => {
    let { name } = parser(tmpl, ['name']);
    return `[[${name} railway halt|${name}]]`
  },
  ferry: (tmpl) => {
    let { name } = parser(tmpl, ['name']);
    return `[[${name} ferry wharf|${name}]]`
  },
  tram: (tmpl) => {
    let { name, dab } = parser(tmpl, ['name', 'dab']);
    if (dab) {
      return `[[${name} tram stop (${dab})|${name}]]`
    }
    return `[[${name} tram stop|${name}]]`
  },
  tstop: (tmpl) => {
    let { name, dab } = parser(tmpl, ['name', 'dab']);
    if (dab) {
      return `[[${name} ${dab} stop|${name}]]`
    }
    return `[[${name} stop|${name}]]`
  },
  // boats
  ship: (tmpl) => {
    let { prefix, name, id } = parser(tmpl, ['prefix', 'name', 'id']);
    prefix = prefix || '';
    return id ? `[[${prefix.toUpperCase()} ${name}]]` : `[[${prefix.toUpperCase()} ${name}]]`
  },
  sclass: (tmpl) => {
    let { cl, type } = parser(tmpl, ['cl', 'type', 'fmt']);
    return `[[${cl}-class ${type} |''${cl}''-class]] [[${type}]]`
  },
  'center block': (tmpl) => {
    let { text } = parser(tmpl, ['text']);
    return text || ''
  },
  align: (tmpl) => {
    let { text } = parser(tmpl, ['dir', 'text']);
    return text || ''
  },
  font: (tmpl) => {
    let { text } = parser(tmpl, ['text']);
    return text || ''
  },
  float: (tmpl) => {
    let { text, dir } = parser(tmpl, ['dir', 'text']);
    if (!text) {
      return dir
    }
    return text || ''
  },
  lower: (tmpl) => {
    let { text, n } = parser(tmpl, ['n', 'text']);
    if (!text) {
      return n
    }
    return text || ''
  },
  splitspan: (tmpl) => {
    let list = parser(tmpl).list || [];
    return (list[0] || '') + '\n' + (list[1] || '')
  },
  bracket: (tmpl) => {
    let { text } = parser(tmpl, ['text']);
    if (text) {
      return `[${text}]`
    }
    return '['
  },

  // https://en.wikipedia.org/wiki/Template:In_title
  'in title': (tmpl) => {
    let { title, text } = parser(tmpl, ['title', 'text']);
    if (text) {
      return text
    }
    if (title) {
      return `All pages with titles containing ${title}` //[[Special: ..]]
    }
    return ''
  },
  'look from': (tmpl) => {
    let { title, text } = parser(tmpl, ['title', 'text']);
    if (text) {
      return text
    }
    if (title) {
      return `All pages with titles beginning with ${title}` //[[Special: ..]]
    }
    return ''
  },

  'literal translation': (tmpl) => {
    let arr = parser(tmpl).list || [];
    arr = arr.map((str) => `'${str}'`);
    return 'lit. ' + arr.join(' or ')
  },
  overset: (tmpl) => {
    let data = parser(tmpl, ['over', 'base']);
    return [data.over || '', data.base || ''].join(' ')
  },
  underset: (tmpl) => {
    let data = parser(tmpl, ['under', 'base']);
    return [data.base || '', data.under || ''].join(' ')
  },
  ceil: (tmpl) => {
    let data = parser(tmpl, ['txt']);
    return `⌈${data.txt}⌉`
  },
  floor: (tmpl) => {
    let data = parser(tmpl, ['txt']);
    return `⌊${data.txt}⌋`
  },
  'vol.': (tmpl) => {
    let data = parser(tmpl, ['n']);
    return `vol. ${data.n}`
  },
  rp: (tmpl) => {
    let data = parser(tmpl, ['page']);
    if (data.pages) {
      return `pp${data.pages}`
    }
    return `p. ${data.page || ''}`
  },
  gaps: (tmpl) => {
    let data = parser(tmpl);
    return data.list.join('  ')
  },
  bra: (tmpl) => {
    let data = parser(tmpl, ['a']);
    return `⟨${data.a || ''}|`
  },
  ket: (tmpl) => {
    let data = parser(tmpl, ['a']);
    return `${data.a || ''}⟩`
  },
  'angle bracket': (tmpl) => {
    let data = parser(tmpl, ['txt']);
    return `⟨${data.txt || ''}⟩`
  },
  'bra-ket': (tmpl) => {
    let data = parser(tmpl, ['a', 'b']);
    return `⟨${data.a || ''}|${data.b || ''}⟩`
  },
  braket: (tmpl) => {
    let data = parser(tmpl, ['sym', 'a', 'b']);
    if (data.sym === 'bra') {
      return `⟨${data.a}|`
    } else if (data.sym === 'ket') {
      return `⟨|${data.a || ''}⟩`
    } else {
      return `⟨${data.a || ''}|${data.b || ''}⟩`
    }
  },
  pars: (tmpl) => {
    let data = parser(tmpl, ['text', 's']);
    return `(${data.text || ''})`
  },
  circumfix: (tmpl) => {
    let data = parser(tmpl, ['text']);
    return `⟩${data.text || ''}⟨`
  },
  fluc: (tmpl) => {
    let data = parser(tmpl, ['val', 'type']);
    let n = Number(data.val);
    if (data['custom label']) {
      return data['custom label']
    }
    if (n > 0) {
      return ` +${n}` //▲
    } else if (n < 0) {
      return ` ${n}` //▼
    } else if (n === 0) {
      return ` no change `
    }
    return data.val || ''
  },

  'p.': (tmpl) => {
    let data = parser(tmpl, ['a', 'b']);
    if (data.b) {
      if (parseInt(data.b, 10)) {
        return `pp. ${data.a}–${data.b}` //page-range
      } else {
        return `pp. ${data.a}${data.b}`
      }
    }
    return `p. ${data.a || ''}`
  },
  subsup: (tmpl) => {
    let data = parser(tmpl, ['symbol', 'subscript', 'superscript']);
    return `${data.symbol || ''} ${data.subscript || ''} ${data.superscript || ''}`
  },
  su: (tmpl) => {
    let data = parser(tmpl, ['p', 'b']);
    return `${data.p || ''} ${data.b || ''}`
  },
  precision: (tmpl) => {
    let data = parser(tmpl, ['num']);
    let num = data.num || '';
    if (!num.match(/\./) && num.match(/0*$/) && num !== '0') {
      return num.match(/0*$/)[0].length * -1
    }
    let dec = num.split(/\./)[1] || '';
    return dec.length
  },
  intmath: (tmpl) => {
    let data = parser(tmpl, ['sign', 'subscript', 'superscript']);
    const signs = {
      int: '∫',
      iint: '∬',
      iiint: '∭',
      oint: '∮',
      varointclockwise: '∲',
      ointctrclockwise: '∳',
      oiint: '∯',
      oiiint: '∰',
    };
    return `${signs[data.sign] || ''} ${data.superscript || ''} ${data.subscript || ''} `
  },
  ldelim: (tmpl) => {
    let data = parser(tmpl, ['a', 'b', 'sub', 'sup']);
    let after = `${data.sub || ''}${data.sup || ''}`;
    if (data.a === 'square') {
      return `[${data.b || ''}]${after}`
    } else if (data.a === 'round') {
      return `(${data.b || ''})${after}`
    } else if (data.a === 'vert') {
      return `|${data.b || ''}|${after}`
    } else if (data.a === 'doublevert') {
      return `||${data.b || ''}||${after}`
    }
    return `${data.b || ''} ${after}`
  },
  multiply: (tmpl) => {
    let data = parser(tmpl, ['a', 'b']);
    return Number(data.a) * Number(data.b)
  },
  sum: (tmpl) => {
    let data = parser(tmpl, ['a', 'b']);
    return Number(data.a) + Number(data.b)
  },
  round: (tmpl) => {
    let data = parser(tmpl, ['val', 'decimals']);
    let n = Number(data.val);
    //todo: handle decimal place
    return Math.round(n) || ''
  },
  rounddown: (tmpl) => {
    let data = parser(tmpl, ['val', 'decimals']);
    let n = Number(data.val);
    //todo: handle decimal place
    return Math.floor(n) || ''
  },
  roundup: (tmpl) => {
    let data = parser(tmpl, ['val', 'decimals']);
    let n = Number(data.val);
    //todo: handle decimal place
    return Math.ceil(n) || ''
  },
  parity: (tmpl) => {
    let data = parser(tmpl, ['val', 'even', 'odd']);
    if (Number(data.val) % 2 === 0) {
      return data.even || 'even'
    }
    return data.odd || 'odd'
  },
  hexadecimal: (tmpl) => {
    let data = parser(tmpl, ['val']);
    let n = Number(data.val);
    if (!n) {
      return data.val
    }
    return n.toString(16).toUpperCase()
  },
  octal: (tmpl) => {
    let data = parser(tmpl, ['val']);
    let n = Number(data.val);
    if (!n) {
      return data.val
    }
    return n.toString(8).toUpperCase() + '₈'
  },
  decimal2base: (tmpl) => {
    let data = parser(tmpl, ['n', 'radix']);
    let n = Number(data.n);
    let radix = Number(data.radix);
    if (!n || !radix) {
      return data.n
    }
    return n.toString(radix).toUpperCase()
  },
  hex2dec: (tmpl) => {
    let data = parser(tmpl, ['val']);
    return parseInt(data.val, 16) || data.val
  },
  ifnotempty: (tmpl) => {
    let data = parser(tmpl, ['cond', 'a', 'b']);
    if (data.cond) {
      return data.a
    }
    return data.b
  },
  both: (tmpl) => {
    let data = parser(tmpl, ['a', 'b']);
    if (data.a && data.b) {
      return '1'
    }
    return ''
  },
  ifnumber: (tmpl) => {
    let data = parser(tmpl, ['n', 'yes', 'no']);
    if (!isNaN(Number(data.n))) {
      return data.yes || '1'
    }
    return data.no || ''
  },
  'order of magnitude': (tmpl) => {
    let data = parser(tmpl, ['val']);
    let num = parseInt(data.val, 10);
    //todo: support decimal forms
    if (num || num === 0) {
      return String(num).length - 1
    }
    return '0'
  },
  'percent and number': (tmpl) => {
    let data = parser(tmpl, ['number', 'total', 'decimals']);
    let n = Number(data.number) / Number(data.total);
    n *= 100;
    let dec = Number(data.decimals) || 0;
    return `${n.toFixed(dec)}% (${Number(data.number).toLocaleString()})`
  },
  music: (tmpl) => {
    let data = parser(tmpl, ['glyph']);
    // these have unicode working character subs
    let glyphs = {
      flat: '♭',
      b: '♭',
      sharp: '♯',
      '#': '♯',
      natural: '♮',
      n: '♮',
      doubleflat: '𝄫',
      bb: '𝄫',
      '##': '𝄪',
      doublesharp: '𝄪',
      quarternote: '♩',
      quarter: '♩',
      treble: '𝄞',
      trebleclef: '𝄞',
      bass: '𝄢',
      bassclef: '𝄢',
      altoclef: '𝄡',
      alto: '𝄡',
      tenor: '𝄡',
      tenorclef: '𝄡',
    };
    if (glyphs.hasOwnProperty(data.glyph)) {
      return glyphs[data.glyph]
    }
    return ''
  },
  simplenuclide: (tmpl) => {
    let data = parser(tmpl, ['name', 'mass']);
    return `[[${data.name}|${data.mass || ''}${data.name}]]`
  },
  'font color': (tmpl) => {
    let data = parser(tmpl, ['fg', 'bg', 'text']);
    if (data.bg && data.text) {
      return data.text
    }
    return data.bg
  },
  'colored link': (tmpl) => {
    let data = parser(tmpl, ['color', 'title', 'text']);
    return `[[${data.title}|${data.text || data.title}]]`
  },
  nftu: (tmpl) => {
    let data = parser(tmpl, ['age', 'team']);
    return `${data.team} U${data.age}`
  },
  tls: (tmpl) => {
    let data = parser(tmpl, ['name', 'one', 'two']);
    let out = `subst:${data.name}`;
    if (data.one) {
      out += '|' + data.one;
    }
    if (data.two) {
      out += '|' + data.two;
    }
    return `{{${out}}}`
  },
};

let shorthands = [
  // {{HWV|251d}} - handel, bach
  ['bwv', 'BWV'],
  ['hwv', 'HWV'],
  ['d.', 'D '], //Deutsch catalogue
  ['aka', 'a.k.a. '],

  // date abbreviations
  ['cf.', 'cf. '],
  ['fl.', 'fl. '],
  ['circa', 'c. '],
  ['born in', 'b. '],
  ['died-in', 'd. '],
  ['married-in', 'm. '],
];
// create a function for each one
let fns$1 = shorthands.reduce((h, a) => {
  let [name, out] = a;
  h[name] = (tmpl) => {
    let { first } = parser(tmpl, ['first']);
    if (first || first === 0) {
      return out + (first || '')
    }
    return out
  };
  return h
}, {});

// return only the name of the template
let justNames = [
  'they',
  'them',
  'their',
  'theirs',
  'themself',
  'they are',
  'they were',
  'they have',
  'they do',
  'he or she',
  'him or her',
  'his or her',
  'his or hers',
  'he/she',
  'him/her',
  'his/her',
];
justNames.forEach((str) => {
  fns$1[str] = str;
});

let templates$a = {};
let more = [
  'sr-latn-cyrl', //first parameter latin, second cyrillic
  'sr-cyrl-latn', //first parameter cyrillic, second latin
  'sr-latn', //one parameter latin
  'sr-cyrl', //one parameter cyrillic
  'sr-cyr',
  'sh-latn-cyrl', //for both Latin and Cyrillic in that order
  'sh-cyrl-latn', //for both Cyrillic and Latin in that order
  'sh-latn', //for Latin
  'sh-cyrl', //for Cyrillic
  'cel-1bd',
  'cel-x-proto',
  'en-emodeng',
  'de-at',
  'de-ch',
  'gem-x-proto',
  'gsw-fr',
  'nds-nl',
  'nl-be',
  'ku-arab',
  'ku-cyrl',
  'pt-br',
  'fra-frc',
  'fra-que',
  'roa-leo',
  'roa-nor',
  'ca-valencia',
  'ast-leo',
  'grc-gre',
  'grc-x-doric',
  'grc-x-proto',
  'grc-x-medieval',
  'cpg',
  'gmy',
  'grc',
  'grk-x-proto',
  'pnt',
  'mga',
  'owl',
  'pgl',
  'sga',
  'wlm',
  'xbm',
  'xcb',
  'xcg',
  'xpi',
  'aae',
  'aln',
  'sq-definite',
  'bs-cyrl',
  'hsb',
  'ltg',
  'orv',
  'prg',
  'rsk',
  'rue',
  'rus',
  'sgs',
  'sla',
  'szl',
  'wen',
  'aoa',
  'chn',
  'cri',
  'dlm',
  'egl',
  'fax',
  'frc',
  'frm',
  'fro',
  'fr-gallo',
  'oc-gascon',
  'gcf',
  'gcr',
  'ist',
  'la-x-medieval',
  'lij-mc',
  'lld',
  'lou',
  'mfe',
  'mol',
  'mwl',
  'mxi',
  'nrf',
  'osc',
  'osp',
  'pcd',
  'pln',
  'rcf',
  'rgn',
  'roa',
  'ruo',
  'rup',
  'ruq',
  'sdc',
  'sdn',
  'src',
  'sro',
  'xvo',
  'bzj',
  'cim',
  'dum',
  'enm',
  'frk',
  'frr',
  'frs',
  'gmh',
  'gml',
  'gmw',
  'goh',
  'gos',
  'gsw',
  'gyn',
  'icr',
  'jam',
  'kri',
  'lng',
  'nb',
  'non',
  'nrn',
  'odt',
  'ofs',
  'osx',
  'pey',
  'sli',
  'srm',
  'srn',
  'stq',
  'swg',
  'vmf',
  'wae',
  'wep',
  'wes',
  'zea',
  'hmd',
  'hoc',
  'kha',
  'mnw',
  'mtq',
  'vi-chunom',
  'vi-hantu',
  'mvi',
  'rys',
  'ryu',
  'yoi',
  'ace',
  'akl',
  'ami',
  'bew',
  'bik',
  'bjn',
  'bya',
  'cal',
  'cbk',
  'cjm',
  'coa',
  'cyo',
  'dev',
  'fil',
  'gad',
  'hil',
  'iba',
  'ibg',
  'ibl',
  'ilp',
  'itv',
  'ivv',
  'jax',
  'kne',
  'krj',
  'kxd',
  'ljp',
  'mad',
  'mak',
  'mdh',
  'mrv',
  'mrw',
  'ms-arab',
  'nia',
  'niu',
  'pau',
  'pwn',
  'rap',
  'rar',
  'sgd',
  'su-fonts',
  'szy',
  'tao',
  'tkl',
  'tsg',
  'tvl',
  'uli',
  'wls',
  'xsb',
  'yap',
  'yka',
  'ckt',
  'itl',
  'brh',
  'oty',
  'tcy',
  'abq',
  'ady',
  'ddo',
  'inh',
  'kbd',
  'lbe',
  'lez',
  'rut',
  'tab',
  'uby',
  'udi',
  'bai',
  'bin',
  'bsq',
  'dag',
  'dyu',
  'efi',
  'fan',
  'fmp',
  'fuc',
  'fuf',
  'gaa',
  'ibb',
  'kbp',
  'kcg',
  'kpo',
  'ktu',
  'lu',
  'lua',
  'lun',
  'mkw',
  'mos',
  'oaa',
  'sjo',
  'ude',
  'anm',
  'bft',
  'blk',
  'brx',
  'dng',
  'kjp',
  'kjz',
  'ksw',
  'lbj',
  'lus',
  'aae',
  'aaq',
  'abe',
  'abq',
  'aca',
  'ace',
  'acf',
  'acm',
  'acw',
  'ady',
  'ae',
  'aeb',
  'aec',
  'aer',
  'afb',
  'aht',
  'aii',
  'aij',
  'ain',
  'aiq',
  'akk',
  'akl',
  'akz',
  'ale',
  'aln',
  'alq',
  'alt',
  'ami',
  'anm',
  'aoa',
  'apj',
  'apm',
  'apw',
  'ayn',
  'arb',
  'arh',
  'ari',
  'arn',
  'arp',
  'arq',
  'ary',
  'arz',
  'asb',
  'ath',
  'ats',
  'awa',
  'axm',
  'azb',
  'azd',
  'azj',
  'bai',
  'bal',
  'ban',
  'bax',
  'bdz',
  'bea',
  'ber',
  'bew',
  'bft',
  'bgn',
  'bho',
  'bik',
  'bin',
  'bjn',
  'bla',
  'blc',
  'blk',
  'bqi',
  'brh',
  'brx',
  'bsk',
  'bsq',
  'bua',
  'bvb',
  'bya',
  'bzj',
  'cal',
  'cay',
  'cbk',
  'ccp',
  'chg',
  'chm',
  'chn',
  'chp',
  'cic',
  'cim',
  'ciw',
  'cjm',
  'cjs',
  'ckb',
  'ckt',
  'cku',
  'cld',
  'clm',
  'cmg',
  'cmn',
  'cms',
  'cnu',
  'coa',
  'coc',
  'coj',
  'com',
  'coo',
  'cop',
  'cpg',
  'crg',
  'crh',
  'cri',
  'crj',
  'crk',
  'crl',
  'crm',
  'cro',
  'csw',
  'csz',
  'ctg',
  'ctm',
  'cyo',
  'dag',
  'dak',
  'ddo',
  'deh',
  'del',
  'den',
  'dev',
  'din',
  'dlm',
  'dng',
  'dum',
  'dyu',
  'efi',
  'egl',
  'egy',
  'elx',
  'eml',
  'ems',
  'cmn',
  'och',
  'yue',
  'mjw',
  'mni',
  'my-name-mlcts',
  'nan',
  'nwc',
  'omp',
  'otb',
  'pwo',
  'sip',
  'xct',
  'xsr',
  '1ca',
  'alt',
  'az-arab',
  'azb',
  'azj',
  'chg',
  'cjs',
  'crh',
  'crh3',
  'kaa',
  'kjh',
  'krc',
  'kum',
  'nog',
  'ota',
  'otk',
  'sah',
  'slr',
  'sty',
  'tt-arab',
  'tt-cyrl',
  'tt-latn',
  'tyv',
  'uniturk',
  'chm',
  'est-sea',
  'fit',
  'fkv',
  'izh',
  'jmy',
  'koi',
  'krl',
  'liv',
  'mdf',
  'mhr',
  'mrj',
  'myv',
  'olo',
  'sia',
  'sjd',
  'sje',
  'sjk',
  'sjt',
  'sju',
  'sma',
  'smi',
  'smj',
  'smn',
  'sms',
  'vep',
  'vot',
  'vro',
  'yrk',
  'din',
  'luo',
  'srr',
  'sus',
  'swh',
  'umb',
  'yao',
];

// more languages
more.forEach((k) => {
  templates$a['lang-' + k] = 0;
});

//https://en.wikipedia.org/wiki/Category:Lang-x_templates
Object.keys(languages).forEach((k) => {
  templates$a['lang-' + k] = 0;
});

var flags = [
  ['🇦🇩', 'and', 'andorra'],
  ['🇦🇪', 'are', 'united arab emirates'],
  ['🇦🇫', 'afg', 'afghanistan'],
  ['🇦🇬', 'atg', 'antigua and barbuda'],
  ['🇦🇮', 'aia', 'anguilla'],
  ['🇦🇱', 'alb', 'albania'],
  ['🇦🇲', 'arm', 'armenia'],
  ['🇦🇴', 'ago', 'angola'],
  ['🇦🇶', 'ata', 'antarctica'],
  ['🇦🇷', 'arg', 'argentina'],
  ['🇦🇸', 'asm', 'american samoa'],
  ['🇦🇹', 'aut', 'austria'],
  ['🇦🇺', 'aus', 'australia'],
  ['🇦🇼', 'abw', 'aruba'],
  ['🇦🇽', 'ala', 'åland islands'],
  ['🇦🇿', 'aze', 'azerbaijan'],
  ['🇧🇦', 'bih', 'bosnia and herzegovina'],
  ['🇧🇧', 'brb', 'barbados'],
  ['🇧🇩', 'bgd', 'bangladesh'],
  ['🇧🇪', 'bel', 'belgium'],
  ['🇧🇫', 'bfa', 'burkina faso'],
  ['🇧🇬', 'bgr', 'bulgaria'],
  ['🇧🇬', 'bul', 'bulgaria'], //dupe
  ['🇧🇭', 'bhr', 'bahrain'],
  ['🇧🇮', 'bdi', 'burundi'],
  ['🇧🇯', 'ben', 'benin'],
  ['🇧🇱', 'blm', 'saint barthélemy'],
  ['🇧🇲', 'bmu', 'bermuda'],
  ['🇧🇳', 'brn', 'brunei darussalam'],
  ['🇧🇴', 'bol', 'bolivia'],
  ['🇧🇶', 'bes', 'bonaire, sint eustatius and saba'],
  ['🇧🇷', 'bra', 'brazil'],
  ['🇧🇸', 'bhs', 'bahamas'],
  ['🇧🇹', 'btn', 'bhutan'],
  ['🇧🇻', 'bvt', 'bouvet island'],
  ['🇧🇼', 'bwa', 'botswana'],
  ['🇧🇾', 'blr', 'belarus'],
  ['🇧🇿', 'blz', 'belize'],
  ['🇨🇦', 'can', 'canada'],
  ['🇨🇨', 'cck', 'cocos (keeling) islands'],
  ['🇨🇩', 'cod', 'congo'],
  ['🇨🇫', 'caf', 'central african republic'],
  ['🇨🇬', 'cog', 'congo'],
  ['🇨🇭', 'che', 'switzerland'],
  ['🇨🇮', 'civ', "côte d'ivoire"],
  ['🇨🇰', 'cok', 'cook islands'],
  ['🇨🇱', 'chl', 'chile'],
  ['🇨🇲', 'cmr', 'cameroon'],
  ['🇨🇳', 'chn', 'china'],
  ['🇨🇴', 'col', 'colombia'],
  ['🇨🇷', 'cri', 'costa rica'],
  ['🇨🇺', 'cub', 'cuba'],
  ['🇨🇻', 'cpv', 'cape verde'],
  ['🇨🇼', 'cuw', 'curaçao'],
  ['🇨🇽', 'cxr', 'christmas island'],
  ['🇨🇾', 'cyp', 'cyprus'],
  ['🇨🇿', 'cze', 'czech republic'],
  ['🇩🇪', 'deu', 'germany'],
  ['🇩🇪', 'ger', 'germany'], //alias
  ['🇩🇯', 'dji', 'djibouti'],
  ['🇩🇰', 'dnk', 'denmark'],
  ['🇩🇲', 'dma', 'dominica'],
  ['🇩🇴', 'dom', 'dominican republic'],
  ['🇩🇿', 'dza', 'algeria'],
  ['🇪🇨', 'ecu', 'ecuador'],
  ['🇪🇪', 'est', 'estonia'],
  ['🇪🇬', 'egy', 'egypt'],
  ['🇪🇭', 'esh', 'western sahara'],
  ['🇪🇷', 'eri', 'eritrea'],
  ['🇪🇸', 'esp', 'spain'],
  ['🇪🇹', 'eth', 'ethiopia'],
  ['🇫🇮', 'fin', 'finland'],
  ['🇫🇯', 'fji', 'fiji'],
  ['🇫🇰', 'flk', 'falkland islands (malvinas)'],
  ['🇫🇲', 'fsm', 'micronesia'],
  ['🇫🇴', 'fro', 'faroe islands'],
  ['🇫🇷', 'fra', 'france'],
  ['🇬🇦', 'gab', 'gabon'],
  ['🇬🇧', 'gbr', 'united kingdom'],
  ['🇬🇩', 'grd', 'grenada'],
  //['🇬🇪', 'geo', 'georgia'],
  ['🇬🇫', 'guf', 'french guiana'],
  ['🇬🇬', 'ggy', 'guernsey'],
  ['🇬🇭', 'gha', 'ghana'],
  ['🇬🇮', 'gib', 'gibraltar'],
  ['🇬🇱', 'grl', 'greenland'],
  ['🇬🇲', 'gmb', 'gambia'],
  ['🇬🇳', 'gin', 'guinea'],
  ['🇬🇵', 'glp', 'guadeloupe'],
  ['🇬🇶', 'gnq', 'equatorial guinea'],
  ['🇬🇷', 'grc', 'greece'],
  ['🇬🇸', 'sgs', 'south georgia'],
  ['🇬🇹', 'gtm', 'guatemala'],
  ['🇬🇺', 'gum', 'guam'],
  ['🇬🇼', 'gnb', 'guinea-bissau'],
  ['🇬🇾', 'guy', 'guyana'],
  ['🇭🇰', 'hkg', 'hong kong'],
  ['🇭🇲', 'hmd', 'heard island and mcdonald islands'],
  ['🇭🇳', 'hnd', 'honduras'],
  ['🇭🇷', 'hrv', 'croatia'],
  ['🇭🇹', 'hti', 'haiti'],
  ['🇭🇺', 'hun', 'hungary'],
  ['🇮🇩', 'idn', 'indonesia'],
  ['🇮🇪', 'irl', 'ireland'],
  ['🇮🇱', 'isr', 'israel'],
  ['🇮🇲', 'imn', 'isle of man'],
  ['🇮🇳', 'ind', 'india'],
  ['🇮🇴', 'iot', 'british indian ocean territory'],
  ['🇮🇶', 'irq', 'iraq'],
  ['🇮🇷', 'irn', 'iran'],
  ['🇮🇸', 'isl', 'iceland'],
  ['🇮🇹', 'ita', 'italy'],
  ['🇯🇪', 'jey', 'jersey'],
  ['🇯🇲', 'jam', 'jamaica'],
  ['🇯🇴', 'jor', 'jordan'],
  ['🇯🇵', 'jpn', 'japan'],
  ['🇰🇪', 'ken', 'kenya'],
  ['🇰🇬', 'kgz', 'kyrgyzstan'],
  ['🇰🇭', 'khm', 'cambodia'],
  ['🇰🇮', 'kir', 'kiribati'],
  ['🇰🇲', 'com', 'comoros'],
  ['🇰🇳', 'kna', 'saint kitts and nevis'],
  ['🇰🇵', 'prk', 'north korea'],
  ['🇰🇷', 'kor', 'south korea'],
  ['🇰🇼', 'kwt', 'kuwait'],
  ['🇰🇾', 'cym', 'cayman islands'],
  ['🇰🇿', 'kaz', 'kazakhstan'],
  ['🇱🇦', 'lao', "lao people's democratic republic"],
  ['🇱🇧', 'lbn', 'lebanon'],
  ['🇱🇨', 'lca', 'saint lucia'],
  ['🇱🇮', 'lie', 'liechtenstein'],
  ['🇱🇰', 'lka', 'sri lanka'],
  ['🇱🇷', 'lbr', 'liberia'],
  ['🇱🇸', 'lso', 'lesotho'],
  ['🇱🇹', 'ltu', 'lithuania'],
  ['🇱🇺', 'lux', 'luxembourg'],
  ['🇱🇻', 'lva', 'latvia'],
  ['🇱🇾', 'lby', 'libya'],
  ['🇲🇦', 'mar', 'morocco'],
  ['🇲🇨', 'mco', 'monaco'],
  ['🇲🇩', 'mda', 'moldova'],
  ['🇲🇪', 'mne', 'montenegro'],
  ['🇲🇫', 'maf', 'saint martin (french part)'],
  ['🇲🇬', 'mdg', 'madagascar'],
  ['🇲🇭', 'mhl', 'marshall islands'],
  ['🇲🇰', 'mkd', 'macedonia'],
  ['🇲🇱', 'mli', 'mali'],
  ['🇲🇲', 'mmr', 'myanmar'],
  ['🇲🇳', 'mng', 'mongolia'],
  ['🇲🇴', 'mac', 'macao'],
  ['🇲🇵', 'mnp', 'northern mariana islands'],
  ['🇲🇶', 'mtq', 'martinique'],
  ['🇲🇷', 'mrt', 'mauritania'],
  ['🇲🇸', 'msr', 'montserrat'],
  ['🇲🇹', 'mlt', 'malta'],
  ['🇲🇺', 'mus', 'mauritius'],
  ['🇲🇻', 'mdv', 'maldives'],
  ['🇲🇼', 'mwi', 'malawi'],
  ['🇲🇽', 'mex', 'mexico'],
  ['🇲🇾', 'mys', 'malaysia'],
  ['🇲🇿', 'moz', 'mozambique'],
  ['🇳🇦', 'nam', 'namibia'],
  ['🇳🇨', 'ncl', 'new caledonia'],
  ['🇳🇪', 'ner', 'niger'],
  ['🇳🇫', 'nfk', 'norfolk island'],
  ['🇳🇬', 'nga', 'nigeria'],
  ['🇳🇮', 'nic', 'nicaragua'],
  ['🇳🇱', 'nld', 'netherlands'],
  ['🇳🇴', 'nor', 'norway'],
  ['🇳🇵', 'npl', 'nepal'],
  ['🇳🇷', 'nru', 'nauru'],
  ['🇳🇺', 'niu', 'niue'],
  ['🇳🇿', 'nzl', 'new zealand'],
  ['🇴🇲', 'omn', 'oman'],
  ['🇵🇦', 'pan', 'panama'],
  ['🇵🇪', 'per', 'peru'],
  ['🇵🇫', 'pyf', 'french polynesia'],
  ['🇵🇬', 'png', 'papua new guinea'],
  ['🇵🇭', 'phl', 'philippines'],
  ['🇵🇰', 'pak', 'pakistan'],
  ['🇵🇱', 'pol', 'poland'],
  ['🇵🇲', 'spm', 'saint pierre and miquelon'],
  ['🇵🇳', 'pcn', 'pitcairn'],
  ['🇵🇷', 'pri', 'puerto rico'],
  ['🇵🇸', 'pse', 'palestinian territory'],
  ['🇵🇹', 'prt', 'portugal'],
  ['🇵🇼', 'plw', 'palau'],
  ['🇵🇾', 'pry', 'paraguay'],
  ['🇶🇦', 'qat', 'qatar'],
  ['🇷🇪', 'reu', 'réunion'],
  ['🇷🇴', 'rou', 'romania'],
  ['🇷🇸', 'srb', 'serbia'],
  ['🇷🇺', 'rus', 'russia'],
  ['🇷🇼', 'rwa', 'rwanda'],
  ['🇸🇦', 'sau', 'saudi arabia'],
  ['🇸🇧', 'slb', 'solomon islands'],
  ['🇸🇨', 'syc', 'seychelles'],
  ['🇸🇩', 'sdn', 'sudan'],
  ['🇸🇪', 'swe', 'sweden'],
  ['🇸🇬', 'sgp', 'singapore'],
  ['🇸🇭', 'shn', 'saint helena, ascension and tristan da cunha'],
  ['🇸🇮', 'svn', 'slovenia'],
  ['🇸🇯', 'sjm', 'svalbard and jan mayen'],
  ['🇸🇰', 'svk', 'slovakia'],
  ['🇸🇱', 'sle', 'sierra leone'],
  ['🇸🇲', 'smr', 'san marino'],
  ['🇸🇳', 'sen', 'senegal'],
  ['🇸🇴', 'som', 'somalia'],
  ['🇸🇷', 'sur', 'suriname'],
  ['🇸🇸', 'ssd', 'south sudan'],
  ['🇸🇹', 'stp', 'sao tome and principe'],
  ['🇸🇻', 'slv', 'el salvador'],
  ['🇸🇽', 'sxm', 'sint maarten (dutch part)'],
  ['🇸🇾', 'syr', 'syrian arab republic'],
  ['🇸🇿', 'swz', 'swaziland'],
  ['🇹🇨', 'tca', 'turks and caicos islands'],
  ['🇹🇩', 'tcd', 'chad'],
  ['🇹🇫', 'atf', 'french southern territories'],
  ['🇹🇬', 'tgo', 'togo'],
  ['🇹🇭', 'tha', 'thailand'],
  ['🇹🇯', 'tjk', 'tajikistan'],
  ['🇹🇰', 'tkl', 'tokelau'],
  // ['🇹🇱', 'tls', 'timor-leste'],
  ['🇹🇲', 'tkm', 'turkmenistan'],
  ['🇹🇳', 'tun', 'tunisia'],
  ['🇹🇴', 'ton', 'tonga'],
  ['🇹🇷', 'tur', 'turkey'],
  ['🇹🇹', 'tto', 'trinidad and tobago'],
  ['🇹🇻', 'tuv', 'tuvalu'],
  ['🇹🇼', 'twn', 'taiwan'],
  ['🇹🇿', 'tza', 'tanzania'],
  ['🇺🇦', 'ukr', 'ukraine'],
  ['🇺🇬', 'uga', 'uganda'],
  ['🇺🇲', 'umi', 'united states minor outlying islands'],
  ['🇺🇸', 'us', 'united states'], //alias
  ['🇺🇸', 'usa', 'united states'],
  ['🇺🇾', 'ury', 'uruguay'],
  ['🇺🇿', 'uzb', 'uzbekistan'],
  ['🇻🇦', 'vat', 'vatican city'],
  ['🇻🇨', 'vct', 'saint vincent and the grenadines'],
  ['🇻🇪', 'ven', 'venezuela'],
  ['🇻🇬', 'vgb', 'virgin islands, british'],
  ['🇻🇮', 'vir', 'virgin islands, u.s.'],
  ['🇻🇳', 'vnm', 'viet nam'],
  ['🇻🇺', 'vut', 'vanuatu'],
  ['🇼🇫', 'wlf', 'wallis and futuna'],
  ['🇼🇸', 'wsm', 'samoa'],
  ['🇾🇪', 'yem', 'yemen'],
  ['🇾🇹', 'myt', 'mayotte'],
  ['🇿🇦', 'zaf', 'south africa'],
  ['🇿🇲', 'zmb', 'zambia'],
  ['🇿🇼 ', 'zwe', 'zimbabwe'],
  //others (later unicode versions)
  ['🇺🇳', 'un', 'united nations'],
  ['🏴󠁧󠁢󠁥󠁮󠁧󠁿', 'eng', 'england'],
  ['🏴󠁧󠁢󠁳󠁣󠁴󠁿', 'sct', 'scotland'],
  ['🏴󠁧󠁢󠁷󠁬󠁳󠁿', 'wal', 'wales'],
  ['🇪🇺', 'eu', 'european union'],
];

const order = ['flag', 'variant'];
let templates$9 = {
  //https://en.wikipedia.org/wiki/Template:Flag
  // {{flag|USA}} →  USA
  flag: (tmpl) => {
    let obj = parser(tmpl, order);
    let name = obj.flag || '';
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]) || [];
    let flag = found[0] || '';
    return `${flag} [[${found[2]}|${name}]]`
  },
  // {{flagcountry|USA}} →  United States
  flagcountry: (tmpl) => {
    let obj = parser(tmpl, order);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]) || [];
    let flag = found[0] || '';
    return `${flag} [[${found[2]}]]`
  },
  // (unlinked flag-country)
  flagcu: (tmpl) => {
    let obj = parser(tmpl, order);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]) || [];
    let flag = found[0] || '';
    return `${flag} ${found[2]}`
  },
  //https://en.wikipedia.org/wiki/Template:Flagicon
  // {{flagicon|USA}} → United States
  flagicon: (tmpl) => {
    let obj = parser(tmpl, order);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]);
    if (!found) {
      return ''
    }
    return `[[${found[2]}|${found[0]}]]`
  },
  //unlinked flagicon
  flagdeco: (tmpl) => {
    let obj = parser(tmpl, order);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]) || [];
    return found[0] || ''
  },
  //same, but a soccer team
  fb: (tmpl) => {
    let obj = parser(tmpl, order);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]);
    if (!found) {
      return ''
    }
    return `${found[0]} [[${found[2]} national football team|${found[2]}]]`
  },
  fbicon: (tmpl) => {
    let obj = parser(tmpl, order);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]);
    if (!found) {
      return ''
    }
    return ` [[${found[2]} national football team|${found[0]}]]`
  },
  flagathlete: (tmpl) => {
    let obj = parser(tmpl, ['name', 'flag', 'variant']);
    obj.flag = (obj.flag || '').toLowerCase();
    let found = flags.find((a) => obj.flag === a[1] || obj.flag === a[2]);
    if (!found) {
      return `[[${obj.name || ''}]]`
    }
    return `${found[0]} [[${obj.name || ''}]] (${found[1].toUpperCase()})`
  },
};
//support {{can}}
flags.forEach((a) => {
  templates$9[a[1]] = () => {
    return a[0]
  };
});

//random misc for inline wikipedia templates

//https://en.wikipedia.org/wiki/Template:Yes
let templates$8 = {};
let cells = [
  'rh',
  'rh2',
  'yes',
  'no',
  'maybe',
  'eliminated',
  'lost',
  'safe',
  'active',
  'site active',
  'coming soon',
  'good',
  'won',
  'nom',
  'sho',
  'longlisted',
  'tba',
  'success',
  'operational',
  'failure',
  'partial',
  'regional',
  'maybecheck',
  'partial success',
  'partial failure',
  'okay',
  'yes-no',
  'some',
  'nonpartisan',
  'pending',
  'unofficial',
  'unofficial2',
  'usually',
  'rarely',
  'sometimes',
  'any',
  'varies',
  'black',
  'non-album single',
  'unreleased',
  'unknown',
  'perhaps',
  'depends',
  'included',
  'dropped',
  'terminated',
  'beta',
  'table-experimental',
  'free',
  'proprietary',
  'nonfree',
  'needs',
  'nightly',
  'release-candidate',
  'planned',
  'scheduled',
  'incorrect',
  'no result',
  'cmain',
  'calso starring',
  'crecurring',
  'cguest',
  'not yet',
  'optional',
];
cells.forEach((str) => {
  templates$8[str] = (tmpl) => {
    let data = parser(tmpl, ['text']);
    return data.text || titlecase(data.template)
  };
});

//these ones have a text result
let moreCells = [
  ['active fire', 'Active'],
  ['site active', 'Active'],
  ['site inactive', 'Inactive'],
  ['yes2', ''],
  ['no2', ''],
  ['ya', '✅'],
  ['na', '❌'],
  ['nom', 'Nominated'],
  ['sho', 'Shortlisted'],
  ['tba', 'TBA'],
  ['maybecheck', '✔️'],
  ['okay', 'Neutral'],
  ['n/a', 'N/A'],
  ['sdash', '—'],
  ['dunno', '?'],
  ['draw', ''],
  ['cnone', ''],
  ['nocontest', ''],
];
moreCells.forEach((a) => {
  templates$8[a[0]] = (tmpl) => {
    let data = parser(tmpl, ['text']);
    return data.text || a[1]
  };
});

var textTmpl = Object.assign({}, hardcoded, templates$c, templates$b, functions, templates$a, fns$1, templates$9, templates$8);

let templates$7 = {};
// these all have ['id', 'name']
let idName = [
  'goodreads author',
  'twitter',
  'facebook',
  'instagram',
  'tumblr',
  'pinterest',
  'espn nfl',
  'espn nhl',
  'espn fc',
  'hockeydb',
  'fifa player',
  'worldcat',
  'worldcat id',
  'nfl player',
  'ted speaker',
  'playmate',
];
idName.forEach((name) => {
  templates$7[name] = ['id', 'name'];
});

let templates$6 = {};
// these all have ['id', 'title', 'description', 'section']
let idTitle = [
  'imdb title', //https://en.wikipedia.org/wiki/Template:IMDb_title
  'imdb name',
  'imdb episode',
  'imdb event',
  'afi film',
  'allmovie title',
  'allgame',
  'tcmdb title',
  'discogs artist',
  'discogs label',
  'discogs release',
  'discogs master',
  'librivox author',
  'musicbrainz artist',
  'musicbrainz label',
  'musicbrainz recording',
  'musicbrainz release',
  'musicbrainz work',
  'youtube',
  'goodreads book',
  'dmoz', //https://en.wikipedia.org/wiki/Template:DMOZ
];
idTitle.forEach((name) => {
  templates$6[name] = ['id', 'title', 'description', 'section'];
});

// dummy templates that get parsed properly already,
// but present here for for aliases + template coverage tests
let templates$5 = {};
let dummies = ['citation needed'];
dummies.forEach((name) => {
  // just parse it and do nothing
  templates$5[name] = (tmpl, list) => {
    list.push(parser(tmpl));
    return ''
  };
});

var fns = {
  // https://en.wikipedia.org/wiki/Template:IPA
  ipa: (tmpl, list) => {
    let obj = parser(tmpl, ['transcription', 'lang', 'audio']);
    obj.lang = getLang(obj.template);
    obj.template = 'ipa';
    list.push(obj);
    return '' //obj.transcription
  },
  //https://en.wikipedia.org/wiki/Template:IPAc-en
  ipac: (tmpl, list) => {
    let obj = parser(tmpl);
    obj.transcription = (obj.list || []).join(',');
    delete obj.list;
    obj.lang = getLang(obj.template);
    obj.template = 'ipac';
    list.push(obj);
    return ''
  },

  quote: (tmpl, list) => {
    let obj = parser(tmpl, ['text', 'author']);
    list.push(obj);
    //create plaintext version
    if (obj.text) {
      let str = `"${obj.text}"`;
      if (obj.author) {
        str += '\n\n';
        str += `    - ${obj.author}`;
      }
      return str + '\n'
    }
    return ''
  },

  //this one sucks - https://en.wikipedia.org/wiki/Template:GNIS
  'cite gnis': (tmpl, list) => {
    let obj = parser(tmpl, ['id', 'name', 'type']);
    obj.type = 'gnis';
    obj.template = 'citation';
    list.push(obj);
    return ''
  },

  'spoken wikipedia': (tmpl, list) => {
    let obj = parser(tmpl, ['file', 'date']);
    obj.template = 'audio';
    list.push(obj);
    return ''
  },

  //yellow card
  yel: (tmpl, list) => {
    let obj = parser(tmpl, ['min']);
    list.push(obj);
    if (obj.min) {
      return `yellow: ${obj.min || ''}'` //no yellow-card emoji
    }
    return ''
  },

  subon: (tmpl, list) => {
    let obj = parser(tmpl, ['min']);
    list.push(obj);
    if (obj.min) {
      return `sub on: ${obj.min || ''}'` //no yellow-card emoji
    }
    return ''
  },

  suboff: (tmpl, list) => {
    let obj = parser(tmpl, ['min']);
    list.push(obj);
    if (obj.min) {
      return `sub off: ${obj.min || ''}'` //no yellow-card emoji
    }
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Sfn
  sfn: (tmpl, list, parser$1, alias) => {
    let obj = parser(tmpl, ['author', 'year', 'location']);
    if (alias) {
      obj.name = obj.template;
      obj.teplate = alias;
    }
    list.push(obj);
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Redirect
  redirect: (tmpl, list) => {
    let data = parser(tmpl, ['redirect']);
    let lines = data.list || [];
    let links = [];
    for (let i = 0; i < lines.length; i += 2) {
      links.push({
        page: lines[i + 1],
        desc: lines[i],
      });
    }
    let obj = {
      template: 'redirect',
      redirect: data.redirect,
      links: links,
    };
    list.push(obj);
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Sister_project_links
  'sister project links': (tmpl, list) => {
    let data = parser(tmpl);
    //rename 'wd' to 'wikidata'
    let links = {};
    Object.keys(sisterProjects).forEach((k) => {
      if (data.hasOwnProperty(k) === true) {
        links[sisterProjects[k]] = data[k]; //.text();
      }
    });
    let obj = {
      template: 'sister project links',
      links: links,
    };
    list.push(obj);
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Subject_bar
  'subject bar': (tmpl, list) => {
    let data = parser(tmpl);
    Object.keys(data).forEach((k) => {
      //rename 'voy' to 'wikivoyage'
      if (sisterProjects.hasOwnProperty(k)) {
        data[sisterProjects[k]] = data[k];
        delete data[k];
      }
    });
    let obj = {
      template: 'subject bar',
      links: data,
    };
    list.push(obj);
    return ''
  },

  //amazingly, this one does not obey any known patterns
  //https://en.wikipedia.org/wiki/Template:Gallery
  gallery: (tmpl, list) => {
    let obj = parser(tmpl);
    let images = (obj.list || []).filter((line) => /^ *File ?:/.test(line));
    images = images.map((file) => {
      let img = {
        file: file,
      };
      // todo: add lang and domain information
      return new Image(img).json()
    });
    obj = {
      template: 'gallery',
      images: images,
    };
    list.push(obj);
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Sky
  sky: (tmpl, list) => {
    let obj = parser(tmpl, [
      'asc_hours',
      'asc_minutes',
      'asc_seconds',
      'dec_sign',
      'dec_degrees',
      'dec_minutes',
      'dec_seconds',
      'distance',
    ]);
    let template = {
      template: 'sky',
      ascension: {
        hours: obj.asc_hours,
        minutes: obj.asc_minutes,
        seconds: obj.asc_seconds,
      },
      declination: {
        sign: obj.dec_sign,
        degrees: obj.dec_degrees,
        minutes: obj.dec_minutes,
        seconds: obj.dec_seconds,
      },
      distance: obj.distance,
    };
    list.push(template);
    return ''
  },

  // Parse https://en.wikipedia.org/wiki/Template:Medical_cases_chart -- see
  // https://en.wikipedia.org/wiki/Module:Medical_cases_chart for the original
  // parsing code.
  'medical cases chart': (tmpl, list) => {
    let order = [
      'date',
      'deathsExpr',
      'recoveriesExpr',
      'casesExpr',
      '4thExpr',
      '5thExpr',
      'col1',
      'col1Change',
      'col2',
      'col2Change',
    ];

    let obj = parser(tmpl);
    obj.data = obj.data || '';
    let rows = obj.data.split('\n');

    // Mimic row parsing in _buildBars in the Lua source, from the following
    // line on:
    //
    //     for parameter in mw.text.gsplit(line, ';') do
    let dataArray = rows.map((row) => {
      let parameters = row.split(';');
      let rowObject = {
        options: new Map(),
      };
      let positionalIndex = 0;
      for (let i = 0; i < parameters.length; i++) {
        let parameter = parameters[i].trim();
        if (parameter.match(/^[a-z_]/i)) {
          // Named argument
          let [key, value] = parameter.split('=');
          // At this point, the Lua code evaluates alttot1 and alttot2 values as
          // #expr expressions, but we just pass them through. See also:
          // https://www.mediawiki.org/wiki/Help:Extension:ParserFunctions##expr
          if (value === undefined) {
            value = null;
          }
          rowObject.options.set(key, value);
        } else {
          // Positional argument
          // Here again, the Lua code evaluates arguments at index 1 through 5
          // as #expr expressions, but we just pass them through.
          if (positionalIndex < order.length) {
            rowObject[order[positionalIndex]] = parameter;
          }
          positionalIndex++;
        }
      }
      for (; positionalIndex < order.length; positionalIndex++) {
        rowObject[order[positionalIndex]] = null;
      }
      return rowObject
    });
    obj.data = dataArray;
    list.push(obj);
    return ''
  },

  graph: (tmpl, list) => {
    let data = parser(tmpl);
    if (data.x) {
      data.x = data.x.split(',').map((str) => str.trim());
    }
    if (data.y) {
      data.y = data.y.split(',').map((str) => str.trim());
    }
    let y = 1;
    while (data['y' + y]) {
      data['y' + y] = data['y' + y].split(',').map((str) => str.trim());
      y += 1;
    }
    list.push(data);
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Historical_populations
  'historical populations': (tmpl, list) => {
    let data = parser(tmpl);
    data.list = data.list || [];
    let years = [];
    for (let i = 0; i < data.list.length; i += 2) {
      let num = data.list[i + 1];
      years.push({
        year: data.list[i],
        val: Number(num) || num,
      });
    }
    data.data = years;
    delete data.list;
    list.push(data);
    return ''
  },

  // this one is a handful!
  //https://en.wikipedia.org/wiki/Template:Weather_box
  'weather box': (tmpl, list) => {
    const hasMonth = /^jan /i;
    const isYear = /^year /i;
    let obj = parser(tmpl);
    const monthList = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
    let byMonth = {};
    let properties = Object.keys(obj).filter((k) => hasMonth.test(k));
    properties = properties.map((k) => k.replace(hasMonth, ''));
    properties.forEach((prop) => {
      byMonth[prop] = [];
      monthList.forEach((m) => {
        let key = `${m} ${prop}`;
        if (obj.hasOwnProperty(key)) {
          let num = toNumber(obj[key]);
          delete obj[key];
          byMonth[prop].push(num);
        }
      });
    });
    //add these to original
    obj.byMonth = byMonth;
    //collect year-based data
    let byYear = {};
    Object.keys(obj).forEach((k) => {
      if (isYear.test(k)) {
        let prop = k.replace(isYear, '');
        byYear[prop] = obj[k];
        delete obj[k];
      }
    });
    obj.byYear = byYear;
    list.push(obj);
    return ''
  },

  //The 36 parameters are: 12 monthly highs (C), 12 lows (total 24) plus an optional 12 monthly rain/precipitation
  //https://en.wikipedia.org/wiki/Template:Weather_box/concise_C
  'weather box/concise c': (tmpl, list) => {
    let obj = parser(tmpl);
    obj.list = obj.list.map((s) => toNumber(s));
    obj.byMonth = {
      'high c': obj.list.slice(0, 12),
      'low c': obj.list.slice(12, 24),
      'rain mm': obj.list.slice(24, 36),
    };
    delete obj.list;
    obj.template = 'weather box';
    list.push(obj);
    return ''
  },

  'weather box/concise f': (tmpl, list) => {
    let obj = parser(tmpl);
    obj.list = obj.list.map((s) => toNumber(s));
    obj.byMonth = {
      'high f': obj.list.slice(0, 12),
      'low f': obj.list.slice(12, 24),
      'rain inch': obj.list.slice(24, 36),
    };
    delete obj.list;
    obj.template = 'weather box';
    list.push(obj);
    return ''
  },

  //https://en.wikipedia.org/wiki/Template:Climate_chart
  'climate chart': (tmpl, list) => {
    let lines = parser(tmpl).list || [];
    let title = lines[0];
    let source = lines[38];
    lines = lines.slice(1);
    //amazingly, they use '−' symbol here instead of negatives...
    lines = lines.map((str) => {
      if (str && str[0] === '−') {
        str = str.replace(/−/, '-');
      }
      return str
    });
    let months = [];
    //groups of three, for 12 months
    for (let i = 0; i < 36; i += 3) {
      months.push({
        low: toNumber(lines[i]),
        high: toNumber(lines[i + 1]),
        precip: toNumber(lines[i + 2]),
      });
    }
    let obj = {
      template: 'climate chart',
      data: {
        title: title,
        source: source,
        months: months,
      },
    };
    list.push(obj);
    return ''
  },
  //https://en.wikipedia.org/wiki/Template:MedalCount
  medalcount: (tmpl, list) => {
    let all = parser(tmpl).list || [];
    let lines = [];
    for (let i = 0; i < all.length; i += 4) {
      lines.push({
        name: all[i],
        '1st': Number(all[i + 1]),
        '2nd': Number(all[i + 2]),
        '3rd': Number(all[i + 3]),
      });
    }
    let obj = {
      template: 'medalcount',
      list: lines,
    };
    list.push(obj);
    return ''
  },

  r: (tmpl, list) => {
    let obj = parser(tmpl, ['name']);
    obj.template = 'citation';
    list.push(obj);
    return ''
  },
};

let templates$4 = {
  //https://en.wikipedia.org/wiki/Category:External_link_templates
  'find a grave': ['id', 'name', 'work', 'last', 'first', 'date', 'accessdate'],
  congbio: ['id', 'name', 'date'],
  'hollywood walk of fame': ['name'],
  'wide image': ['file', 'width', 'caption'],
  audio: ['file', 'text', 'type'],
  rp: ['page'],
  'short description': ['description'],
  'coord missing': ['region'],
  unreferenced: ['date'],
  'taxon info': ['taxon', 'item'], //https://en.wikipedia.org/wiki/Template:Taxon_info
  'portuguese name': ['first', 'second', 'suffix'], // https://en.wikipedia.org/wiki/Template:Portuguese_name
  geo: ['lat', 'lon', 'zoom'], //https://en.wikivoyage.org/wiki/Template:Geo
  hatnote: ['text'],
};

templates$4 = Object.assign(templates$4, templates$5, templates$7, templates$6, fns);

var dataTmpl = templates$4;

const mlbplayer = {
  props: ['number', 'name', 'il'],
  out: 'name',
};
const syntaxhighlight = {
  props: [],
  out: 'code',
};
const samp = {
  props: ['1'],
  out: '1',
};
const sub = {
  props: ['text'],
  out: 'text',
};
const sup = {
  props: ['text'],
  out: 'text',
};
const chem2 = {
  props: ['equation'],
  out: 'equation',
};
const ill = {
  props: ['text', 'lan1', 'text1', 'lan2', 'text2'],
  out: 'text',
};
const abbr = {
  props: ['abbr', 'meaning', 'ipa'],
  out: 'abbr',
};

var shorthand = {
  mlbplayer,
  syntaxhighlight,
  samp,
  sub,
  sup,
  chem2,
  ill,
  abbr,
};

let templates$3 = {
  // https://en.wikipedia.org/wiki/Template:Math
  math: (tmpl, list) => {
    let obj = parser(tmpl, ['formula']);
    list.push(obj);
    return '\n\n' + (obj.formula || '') + '\n\n'
  },

  //svg labels - https://en.m.wikipedia.org/wiki/Template:Legend
  legend: (tmpl, list) => {
    let obj = parser(tmpl, ['color', 'label']);
    list.push(obj);
    // return obj.label || ' '
    return tmpl // keep the wiki?
  },

  isbn: (tmpl, list) => {
    let obj = parser(tmpl, ['id', 'id2', 'id3']);
    list.push(obj);
    return 'ISBN ' + (obj.id || '')
  },

  //https://en.wikipedia.org/wiki/Template:Based_on
  'based on': (tmpl, list) => {
    let obj = parser(tmpl, ['title', 'author']);
    list.push(obj);
    return `${obj.title} by ${obj.author || ''}`
  },

  //barrels of oil https://en.wikipedia.org/wiki/Template:Bbl_to_t
  'bbl to t': (tmpl, list) => {
    let obj = parser(tmpl, ['barrels']);
    list.push(obj);
    if (obj.barrels === '0') {
      return obj.barrels + ' barrel'
    }
    return obj.barrels + ' barrels'
  },

  //minor planet - https://en.wikipedia.org/wiki/Template:MPC
  mpc: (tmpl, list) => {
    let obj = parser(tmpl, ['number', 'text']);
    list.push(obj);
    return `[https://minorplanetcenter.net/db_search/show_object?object_id=P/2011+NO1 ${obj.text || obj.number}]`
  },

  pengoal: (_tmpl, list) => {
    list.push({
      template: 'pengoal',
    });
    return '✅'
  },

  penmiss: (_tmpl, list) => {
    list.push({
      template: 'penmiss',
    });
    return '❌'
  },

  // https://en.wikipedia.org/wiki/Template:Ordered_list
  'ordered list': (tmpl, list) => {
    let obj = parser(tmpl);
    list.push(obj);
    obj.list = obj.list || [];
    let lines = obj.list.map((str, i) => `${i + 1}. ${str}`);
    return lines.join('\n\n')
  },

  // https://en.wikipedia.org/wiki/Template:Title_year
  'title year': (tmpl, _list, _alias, _parse, doc) => {
    let obj = parser(tmpl, ['match', 'nomatch', 'page']);
    let title = obj.page || doc.title();
    if (title) {
      let m = title.match(/\b[0-9]{4}\b/); //parse the year out of the title's name
      if (m) {
        return m[0]
      }
    }
    return obj.nomatch || '' //use default response
  },

  // https://en.wikipedia.org/wiki/Template:Title_century
  'title century': (tmpl, _list, _alias, _parse, doc) => {
    let obj = parser(tmpl, ['match', 'nomatch', 'page']);
    let title = obj.page || doc.title();
    if (title) {
      let m = title.match(/\b([0-9]+)(st|nd|rd|th)\b/); //parse the century out of the title's name
      if (m) {
        return m[1] || ''
      }
    }
    return obj.nomatch || '' //use default response
  },

  // https://en.wikipedia.org/wiki/Template:Title_decade
  'title decade': (tmpl, _list, _alias, _parse, doc) => {
    let obj = parser(tmpl, ['match', 'nomatch', 'page']);
    let title = obj.page || doc.title();
    if (title) {
      let m = title.match(/\b([0-9]+)s\b/); //parse the decade out of the title's name
      if (m) {
        return m[1] || ''
      }
    }
    return obj.nomatch || '' //use default response
  },

  //https://en.wikipedia.org/wiki/Template:Nihongo
  nihongo: (tmpl, list) => {
    let obj = parser(tmpl, ['english', 'kanji', 'romaji', 'extra']);
    list.push(obj);
    let str = obj.english || obj.romaji || '';
    if (obj.kanji) {
      str += ` (${obj.kanji})`;
    }
    return str
  },

  //https://en.wikipedia.org/wiki/Template:Marriage
  //this one creates a template, and an inline response
  marriage: (tmpl, list) => {
    let data = parser(tmpl, ['spouse', 'from', 'to', 'end']);
    list.push(data);
    let str = data.spouse || '';
    if (data.from) {
      if (data.to) {
        str += ` (m. ${data.from}-${data.to})`;
      } else {
        str += ` (m. ${data.from})`;
      }
    }
    return str
  },

  //'red' card - {{sent off|cards|min1|min2}}
  'sent off': (tmpl, list) => {
    let obj = parser(tmpl, ['cards']);
    let result = {
      template: 'sent off',
      cards: obj.cards,
      minutes: obj.list || [],
    };
    list.push(result);
    let mins = result.minutes.map((m) => m + "'").join(', ');
    return 'sent off: ' + mins
  },

  transl: (tmpl, list) => {
    let obj = parser(tmpl, ['lang', 'text', 'text2']);
    // support 3-param
    if (obj.text2) {
      obj.iso = obj.text;
      obj.text = obj.text2;
      delete obj.text2;
    }
    list.push(obj);
    return obj.text || ''
  },

  //show/hide: https://en.wikipedia.org/wiki/Template:Collapsible_list
  'collapsible list': (tmpl, list) => {
    let obj = parser(tmpl);
    list.push(obj);
    let str = '';
    if (obj.title) {
      str += `'''${obj.title}'''` + '\n\n';
    }
    if (!obj.list) {
      obj.list = [];
      for (let i = 1; i < 10; i += 1) {
        if (obj[i]) {
          obj.list.push(obj[i]);
          delete obj[i];
        }
      }
    }
    obj.list = obj.list.filter((s) => s);
    str += obj.list.join('\n\n');
    return str
  },

  //https://en.wikipedia.org/wiki/Template:Columns-list
  'columns-list': (tmpl, list) => {
    let arr = parser(tmpl).list || [];
    let str = arr[0] || '';
    let lines = str.split(/\n/).filter((f) => f);
    lines = lines.map((s) => s.replace(/\*/, ''));
    list.push({
      template: 'columns-list',
      list: lines,
    });
    lines = lines.map((s) => '• ' + s);
    return lines.join('\n\n')
  },

  //https://en.wikipedia.org/wiki/Template:Height - {{height|ft=6|in=1}}
  height: (tmpl, list) => {
    let obj = parser(tmpl);
    list.push(obj);
    let result = [];
    let units = ['m', 'cm', 'ft', 'in']; //order matters
    units.forEach((unit) => {
      if (obj.hasOwnProperty(unit) === true) {
        result.push(obj[unit] + unit);
      }
    });
    return result.join(' ')
  },

  //https://en.wikipedia.org/wiki/Template:Sic
  sic: (tmpl, list) => {
    let obj = parser(tmpl, ['one', 'two', 'three']);
    let word = (obj.one || '') + (obj.two || '');
    //support '[sic?]'
    if (obj.one === '?') {
      word = (obj.two || '') + (obj.three || '');
    }
    list.push({
      template: 'sic',
      word: word,
    });
    if (obj.nolink === 'y') {
      return word
    }
    return `${word} [sic]`
  },

  //
  inrconvert: (tmpl, list) => {
    let o = parser(tmpl, ['rupee_value', 'currency_formatting']);
    list.push(o);
    const mults = {
      k: 1000,
      m: 1000000,
      b: 1000000000,
      t: 1000000000000,
      l: 100000,
      c: 10000000,
      lc: 1000000000000,
    };
    if (o.currency_formatting) {
      let multiplier = mults[o.currency_formatting] || 1;
      o.rupee_value = o.rupee_value * multiplier;
    }
    return `inr ${o.rupee_value || ''}`
  },

  //fraction - https://en.wikipedia.org/wiki/Template:Sfrac
  frac: (tmpl, list) => {
    let obj = parser(tmpl, ['a', 'b', 'c']);
    let data = {
      template: 'sfrac',
    };
    if (obj.c) {
      data.integer = obj.a;
      data.numerator = obj.b;
      data.denominator = obj.c;
    } else if (obj.b) {
      data.numerator = obj.a;
      data.denominator = obj.b;
    } else {
      data.numerator = 1;
      data.denominator = obj.a;
    }
    list.push(data);
    if (data.integer) {
      return `${data.integer} ${data.numerator}⁄${data.denominator}`
    }
    return `${data.numerator}⁄${data.denominator}`
  },

  'winning percentage': (tmpl, list) => {
    let obj = parser(tmpl, ['wins', 'losses', 'ties']);
    list.push(obj);
    let wins = Number(obj.wins);
    let losses = Number(obj.losses);
    let ties = Number(obj.ties) || 0;
    let games = wins + losses + ties;
    if (obj.ignore_ties === 'y') {
      ties = 0;
    }
    if (ties) {
      wins += ties / 2;
    }
    let num = percentage({
      numerator: wins,
      denominator: games,
      decimals: 1,
    });
    if (num === null) {
      return ''
    }
    return `.${num * 10}`
  },

  winlosspct: (tmpl, list) => {
    let obj = parser(tmpl, ['wins', 'losses']);
    list.push(obj);
    let wins = Number(obj.wins);
    let losses = Number(obj.losses);
    let num = percentage({
      numerator: wins,
      denominator: wins + losses,
      decimals: 1,
    });
    if (num === null) {
      return ''
    }
    let out = `.${num * 10}`;
    return `${wins || 0} || ${losses || 0} || ${out || '-'}`
  },

  //https://en.wikipedia.org/wiki/Template:Video_game_release
  'video game release': (tmpl, list) => {
    let order = ['region', 'date', 'region2', 'date2', 'region3', 'date3', 'region4', 'date4'];
    let obj = parser(tmpl, order);
    let template = {
      template: 'video game release',
      releases: [],
    };
    for (let i = 0; i < order.length; i += 2) {
      if (obj[order[i]]) {
        template.releases.push({
          region: obj[order[i]],
          date: obj[order[i + 1]],
        });
      }
    }
    list.push(template);
    let str = template.releases.map((o) => `${o.region}: ${o.date || ''}`).join('\n\n');
    return '\n' + str + '\n'
  },
  // https://en.m.wikipedia.org/wiki/Template:USS
  uss: (tmpl, list) => {
    let obj = parser(tmpl, ['name', 'id']);
    list.push(obj);
    if (obj.id) {
      return `[[USS ${obj.name} (${obj.id})|USS ''${obj.name}'' (${obj.id})]]`
    }
    return `[[USS ${obj.name}|USS ''${obj.name}'']]`
  },
  // https://en.wikipedia.org/wiki/Template:Blockquote
  blockquote: (tmpl, list) => {
    let props = ['text', 'author', 'title', 'source', 'character'];
    let obj = parser(tmpl, props);
    list.push(obj);
    let txt = obj.text;
    // used first un-named param
    if (!txt) {
      obj.list = obj.list || [];
      txt = obj.list[0] || '';
    }
    // replace double quotes with singles and put the text inside double quotes
    let result = txt.replace(/"/g, "'");
    result = '"' + result + '"';
    return result
  },

  // https://de.m.wikipedia.org/wiki/Vorlage:ReptileDatabase
  ReptileDatabase: (tmpl, list) => {
    let obj = parser(tmpl, ['taxon', 'genus', 'species', 'abruf', 'pure_url']);
    list.push(obj);
    let str = '';
    if (obj.genus || obj.species) {
      str = `${obj.genus || ''} ${obj.species || ''} `;
    }
    return `${str}In: [[The Reptile Database]]`
  },
  //https://en.m.wikipedia.org/wiki/Template:GEOnet3
  GEOnet3: (tmpl, list) => {
    let obj = parser(tmpl, ['ufi', 'name']);
    list.push(obj);
    return `GEOnet3 can be found at [[GEOnet Names Server]], at [http://geonames.nga.mil/namesgaz/ this link]`
  },
  'poem quote': (tmpl, list) => {
    let obj = parser(tmpl, ['text', 'char', 'sign', 'source', 'title']);
    list.push(obj);
    let out = obj.text || '';
    if (obj.char || obj.sign || obj.source || obj.title) {
      out += '\n\n —';
      out += obj.char ? ' ' + obj.char : '';
      out += obj.sign ? ' ' + obj.sign : '';
      out += obj.source ? ' ' + obj.source : '';
      out += obj.title ? ' ' + obj.title : '';
    }
    return out
  },
  tweet: (tmpl, list) => {
    let obj = parser(tmpl);
    list.push(obj);
    let out = obj.text || '';
    out += obj.date ? ' ' + obj.date : '';
    return out
  },
};

const codes$1 = {
  '£': 'GB£', // https://en.wikipedia.org/wiki/Template:GBP
  '¥': '¥', // https://en.wikipedia.org/wiki/Template:JPY
  '৳': '৳', // https://en.wikipedia.org/wiki/Template:BDT
  '₩': '₩', // https://en.wikipedia.org/wiki/Template:SK_won
  '€': '€', // https://en.wikipedia.org/wiki/Template:€
  '₱': '₱', // https://en.wikipedia.org/wiki/Template:Philippine_peso
  '₹': '₹', // https://en.wikipedia.org/wiki/Template:Indian_Rupee
  '₽': '₽', // https://en.wikipedia.org/wiki/Template:RUB
  'cn¥': 'CN¥', // https://en.wikipedia.org/wiki/Template:CNY
  'gb£': 'GB£', // https://en.wikipedia.org/wiki/Template:GBP
  'india rs': '₹', // https://en.wikipedia.org/wiki/Template:Indian_Rupee
  'indian rupee symbol': '₹', // https://en.wikipedia.org/wiki/Template:Indian_Rupee
  'indian rupee': '₹', // https://en.wikipedia.org/wiki/Template:Indian_Rupee
  'indian rupees': '₹', // https://en.wikipedia.org/wiki/Template:Indian_Rupee
  'philippine peso': '₱', // https://en.wikipedia.org/wiki/Template:Philippine_peso
  'russian ruble': '₽', // https://en.wikipedia.org/wiki/Template:Russian_ruble
  'SK won': '₩', // https://en.wikipedia.org/wiki/Template:SK_won
  'turkish lira': 'TRY', //https://en.wikipedia.org/wiki/Template:Turkish_lira
  a$: 'A$', // https://en.wikipedia.org/wiki/Template:AUD
  au$: 'A$', //https://en.wikipedia.org/wiki/Template:AUD
  aud: 'A$', //https://en.wikipedia.org/wiki/Template:AUD
  bdt: 'BDT', //https://en.wikipedia.org/wiki/Template:BDT
  brl: 'BRL', //https://en.wikipedia.org/wiki/Template:BRL
  ca$: 'CA$', // https://en.wikipedia.org/wiki/Template:CAD
  cad: 'CA$', // https://en.wikipedia.org/wiki/Template:CAD
  chf: 'CHF', // https://en.wikipedia.org/wiki/Template:CHF
  cny: 'CN¥', // https://en.wikipedia.org/wiki/Template:CNY
  czk: 'czk', // https://en.wikipedia.org/wiki/Template:CZK
  dkk: 'dkk', // https://en.wikipedia.org/wiki/Template:DKK
  dkk2: 'dkk', // https://en.wikipedia.org/wiki/Template:DKK
  euro: '€', // https://en.wikipedia.org/wiki/Template:€
  gbp: 'GB£', // https://en.wikipedia.org/wiki/Template:GBP
  hk$: 'HK$', // https://en.wikipedia.org/wiki/Template:HKD
  hkd: 'HK$', // https://en.wikipedia.org/wiki/Template:HKD
  ils: 'ILS', // https://en.wikipedia.org/wiki/Template:ILS
  inr: '₹', // https://en.wikipedia.org/wiki/Template:Indian_Rupee
  jpy: '¥', // https://en.wikipedia.org/wiki/Template:JPY
  myr: 'MYR', // https://en.wikipedia.org/wiki/Template:MYR
  nis: 'ILS', // https://en.wikipedia.org/wiki/Template:ILS
  nok: 'NOK', //https://en.wikipedia.org/wiki/Template:NOK
  nok2: 'NOK', //https://en.wikipedia.org/wiki/Template:NOK
  nz$: 'NZ$', //https://en.wikipedia.org/wiki/Template:NZD
  nzd: 'NZ$', //https://en.wikipedia.org/wiki/Template:NZD
  peso: 'peso', //https://en.wikipedia.org/wiki/Template:Peso
  pkr: '₨', // https://en.wikipedia.org/wiki/Template:Pakistani_Rupee
  r$: 'BRL', //https://en.wikipedia.org/wiki/Template:BRL
  rmb: 'CN¥', // https://en.wikipedia.org/wiki/Template:CNY
  rub: '₽', // https://en.wikipedia.org/wiki/Template:RUB
  ruble: '₽', // https://en.wikipedia.org/wiki/Template:Ruble
  rupee: '₹', // https://en.wikipedia.org/wiki/Template:Rupee
  s$: 'sgd', // https://en.wikipedia.org/wiki/Template:SGD
  sek: 'SEK', // https://en.wikipedia.org/wiki/Template:SEK
  sek2: 'SEK', // https://en.wikipedia.org/wiki/Template:SEK
  sfr: 'CHF', // https://en.wikipedia.org/wiki/Template:CHF
  sgd: 'sgd', // https://en.wikipedia.org/wiki/Template:SGD
  shekel: 'ILS', // https://en.wikipedia.org/wiki/Template:ILS
  sheqel: 'ILS', // https://en.wikipedia.org/wiki/Template:ILS
  ttd: 'TTD', //https://en.wikipedia.org/wiki/Template:TTD
  us$: 'US$', // https://en.wikipedia.org/wiki/Template:US$
  usd: 'US$', // https://en.wikipedia.org/wiki/Template:US$
  yen: '¥', // https://en.wikipedia.org/wiki/Template:JPY
  zar: 'R', //https://en.wikipedia.org/wiki/Template:ZAR
};

const parseCurrency = (tmpl, list) => {
  let o = parser(tmpl, ['amount', 'code']);
  list.push(o);
  let code = o.template || '';
  if (code === 'currency') {
    code = o.code;
    if (!code) {
      o.code = code = 'usd'; //Special case when currency template has no code argument
    }
  } else if (code === '' || code === 'monnaie' || code === 'unité' || code === 'nombre' || code === 'nb') {
    code = o.code;
  }
  code = (code || '').toLowerCase();
  if (code === 'us') {
    o.code = code = 'usd';
  } else if (code === 'uk') {
    o.code = code = 'gbp';
  }
  let str = `${codes$1[code] || ''}${o.amount || ''}`;
  //support unknown currencies after the number - like '5 BTC'
  if (o.code && !codes$1[o.code.toLowerCase()]) {
    str += ' ' + o.code;
  }
  return str
};

let templates$2 = {
  currency: parseCurrency,
};
//and the others fit the same pattern
Object.keys(codes$1).forEach((k) => {
  templates$2[k] = parseCurrency;
});

//this is allowed to be rough
const day = 1000 * 60 * 60 * 24;
const month = day * 30;
const year = day * 365;

const getEpoch = function (obj) {
  return new Date(`${obj.year}-${obj.month || 0}-${obj.date || 1}`).getTime()
};

//very rough!
const delta = function (from, to) {
  from = getEpoch(from);
  to = getEpoch(to);
  let diff = to - from;
  let obj = {};
  //get years
  let years = Math.floor(diff / year);
  if (years > 0) {
    obj.years = years;
    diff -= obj.years * year;
  }
  //get months
  let monthCount = Math.floor(diff / month);
  if (monthCount > 0) {
    obj.months = monthCount;
    diff -= obj.months * month;
  }
  //get days
  let days = Math.floor(diff / day);
  if (days > 0) {
    obj.days = days;
    // diff -= (obj.days * day);
  }
  return obj
};

//not all too fancy - used in {{timesince}}
const timeSince = function (str) {
  let d = new Date(str);
  if (isNaN(d.getTime())) {
    return ''
  }
  let now = new Date();
  let delt = now.getTime() - d.getTime();
  let predicate = 'ago';
  if (delt < 0) {
    predicate = 'from now';
    delt = Math.abs(delt);
  }
  //figure out units
  let hours = delt / 1000 / 60 / 60;
  let days = hours / 24;
  if (days < 365) {
    return Number(days) + ' days ' + predicate
  }
  let years = days / 365;
  return Number(years) + ' years ' + predicate
};

const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];

//assorted parsing methods for date/time templates
const months$1 = [
  undefined, //1-based months.. :/
  'January',
  'February',
  'March',
  'April',
  'May',
  'June',
  'July',
  'August',
  'September',
  'October',
  'November',
  'December',
];

const monthName = months$1.reduce((h, str, i) => {
  if (i === 0) {
    return h
  }
  h[str.toLowerCase()] = i;
  h[str.substring(0, 3).toLowerCase()] = i;
  return h
}, {});

//parse year|month|date numbers
const ymd = function (arr) {
  let obj = {};
  let units = ['year', 'month', 'date', 'hour', 'minute', 'second'];
  //parse each unit in sequence..
  for (let i = 0; i < units.length; i += 1) {
    //skip it
    if (!arr[i] && arr[1] !== 0) {
      continue
    }
    let num = parseInt(arr[i], 10);
    if (isNaN(num) === false) {
      obj[units[i]] = num; //we good.
    } else if (units[i] === 'month') {
      let m = arr[i].toLowerCase().trim();
      //try for month-name, like 'january
      if (monthName.hasOwnProperty(m)) {
        let month = monthName[m];
        obj[units[i]] = month;
      }
    } else {
      //we dead. so skip this unit
      delete obj[units[i]];
    }
  }
  //try for timezone,too ftw
  let last = arr[arr.length - 1] || '';
  last = String(last);
  if (last.toLowerCase() === 'z') {
    obj.tz = 'UTC';
  } else if (/[+-][0-9]+:[0-9]/.test(last)) {
    obj.tz = arr[6];
  }
  return obj
};

//zero-pad a number
const pad = function (num) {
  if (num < 10) {
    return '0' + num
  }
  return String(num)
};

const toText = function (date) {
  //eg '1995'
  let str = String(date.year || '');
  if (date.month !== undefined && months$1.hasOwnProperty(date.month) === true) {
    if (date.date === undefined) {
      //January 1995
      str = `${months$1[date.month]} ${date.year}`;
    } else {
      //January 5, 1995
      str = `${months$1[date.month]} ${date.date}, ${date.year}`;
      //add times, if available
      if (date.hour !== undefined && date.minute !== undefined) {
        let time = `${pad(date.hour)}:${pad(date.minute)}`;
        if (date.second !== undefined) {
          time = time + ':' + pad(date.second);
        }
        str = time + ', ' + str;
        //add timezone, if there, at the end in brackets
      }
      if (date.tz) {
        str += ` (${date.tz})`;
      }
    }
  }
  return str
};

// console.log(toText(ymd([2018, 3, 28])));

//wrap it up as a template
const template = function (date) {
  return {
    template: 'date',
    data: date,
  }
};

const getBoth = function (tmpl) {
  tmpl = strip(tmpl);
  let arr = tmpl.split('|');
  let from = ymd(arr.slice(1, 4));
  let to = arr.slice(4, 7);
  //assume now, if 'to' is empty
  if (to.length === 0) {
    let d = new Date();
    to = [d.getFullYear(), d.getMonth(), d.getDate()];
  }
  to = ymd(to);
  return {
    from: from,
    to: to,
  }
};

const parsers = {
  //generic {{date|year|month|date}} template
  date: (tmpl, list) => {
    let order = ['year', 'month', 'date', 'hour', 'minute', 'second', 'timezone'];
    let obj = parser(tmpl, order);
    let data = ymd([obj.year, obj.month, obj.date || obj.day]);
    obj.text = toText(data); //make the replacement string
    if (obj.timezone) {
      if (obj.timezone === 'Z') {
        obj.timezone = 'UTC';
      }
      obj.text += ` (${obj.timezone})`;
    }
    if (obj.hour && obj.minute) {
      if (obj.second) {
        obj.text = `${obj.hour}:${obj.minute}:${obj.second}, ` + obj.text;
      } else {
        obj.text = `${obj.hour}:${obj.minute}, ` + obj.text;
      }
    }
    if (obj.text) {
      list.push(template(obj));
    }
    return obj.text
  },

  //support parsing of 'February 10, 1992'
  natural_date: (tmpl, list) => {
    let obj = parser(tmpl, ['text']);
    let str = obj.text || '';
    // - just a year
    let date = {};
    if (/^[0-9]{4}$/.test(str)) {
      date.year = parseInt(str, 10);
    } else {
      //parse the date, using the js date object (for now?)
      let txt = str.replace(/[a-z]+\/[a-z]+/i, '');
      txt = txt.replace(/[0-9]+:[0-9]+(am|pm)?/i, '');
      let d = new Date(txt);
      if (isNaN(d.getTime()) === false) {
        date.year = d.getFullYear();
        date.month = d.getMonth() + 1;
        date.date = d.getDate();
      }
    }
    list.push(template(date));
    return str.trim()
  },

  //just grab the first value, and assume it's a year
  one_year: (tmpl, list) => {
    let obj = parser(tmpl, ['year']);
    let year = Number(obj.year);
    list.push(
      template({
        year: year,
      })
    );
    return String(year)
  },

  //assume 'y|m|d' | 'y|m|d' // {{BirthDeathAge|B|1976|6|6|1990|8|8}}
  two_dates: (tmpl, list) => {
    let order = ['b', 'birth_year', 'birth_month', 'birth_date', 'death_year', 'death_month', 'death_date'];
    let obj = parser(tmpl, order);
    //'b' means show birth-date, otherwise show death-date
    if (obj.b && obj.b.toLowerCase() === 'b') {
      let date = ymd([obj.birth_year, obj.birth_month, obj.birth_date]);
      list.push(template(date));
      return toText(date)
    }
    let date = ymd([obj.death_year, obj.death_month, obj.death_date]);
    list.push(template(date));
    return toText(date)
  },

  age: (tmpl) => {
    let d = getBoth(tmpl);
    let diff = delta(d.from, d.to);
    return diff.years || 0
  },

  'diff-y': (tmpl) => {
    let d = getBoth(tmpl);
    let diff = delta(d.from, d.to);
    if (diff.years === 1) {
      return diff.years + ' year'
    }
    return (diff.years || 0) + ' years'
  },

  'diff-ym': (tmpl) => {
    let d = getBoth(tmpl);
    let diff = delta(d.from, d.to);
    let arr = [];
    if (diff.years === 1) {
      arr.push(diff.years + ' year');
    } else if (diff.years && diff.years !== 0) {
      arr.push(diff.years + ' years');
    }
    if (diff.months === 1) {
      arr.push('1 month');
    } else if (diff.months && diff.months !== 0) {
      arr.push(diff.months + ' months');
    }
    return arr.join(', ')
  },

  'diff-ymd': (tmpl) => {
    let d = getBoth(tmpl);
    let diff = delta(d.from, d.to);
    let arr = [];
    if (diff.years === 1) {
      arr.push(diff.years + ' year');
    } else if (diff.years && diff.years !== 0) {
      arr.push(diff.years + ' years');
    }
    if (diff.months === 1) {
      arr.push('1 month');
    } else if (diff.months && diff.months !== 0) {
      arr.push(diff.months + ' months');
    }
    if (diff.days === 1) {
      arr.push('1 day');
    } else if (diff.days && diff.days !== 0) {
      arr.push(diff.days + ' days');
    }
    return arr.join(', ')
  },

  'diff-yd': (tmpl) => {
    let d = getBoth(tmpl);
    let diff = delta(d.from, d.to);
    let arr = [];
    if (diff.years === 1) {
      arr.push(diff.years + ' year');
    } else if (diff.years && diff.years !== 0) {
      arr.push(diff.years + ' years');
    }
    //ergh...
    diff.days += (diff.months || 0) * 30;
    if (diff.days === 1) {
      arr.push('1 day');
    } else if (diff.days && diff.days !== 0) {
      arr.push(diff.days + ' days');
    }
    return arr.join(', ')
  },

  'diff-d': (tmpl) => {
    let d = getBoth(tmpl);
    let diff = delta(d.from, d.to);
    let arr = [];
    //ergh...
    diff.days += (diff.years || 0) * 365;
    diff.days += (diff.months || 0) * 30;
    if (diff.days === 1) {
      arr.push('1 day');
    } else if (diff.days && diff.days !== 0) {
      arr.push(diff.days + ' days');
    }
    return arr.join(', ')
  },
};

const months = [
  'January',
  'February',
  'March',
  'April',
  'May',
  'June',
  'July',
  'August',
  'September',
  'October',
  'November',
  'December',
];

//date- templates we support
var dates = {
  currentday: () => {
    let d = new Date();
    return String(d.getDate())
  },
  currentdayname: () => {
    let d = new Date();
    return days[d.getDay()]
  },
  currentmonth: () => {
    let d = new Date();
    return months[d.getMonth()]
  },
  currentyear: () => {
    let d = new Date();
    return String(d.getFullYear())
  },
  monthyear: () => {
    let d = new Date();
    return months[d.getMonth()] + ' ' + d.getFullYear()
  },
  'monthyear-1': () => {
    let d = new Date();
    d.setMonth(d.getMonth() - 1);
    return months[d.getMonth()] + ' ' + d.getFullYear()
  },
  'monthyear+1': () => {
    let d = new Date();
    d.setMonth(d.getMonth() + 1);
    return months[d.getMonth()] + ' ' + d.getFullYear()
  },

  year: (tmpl) => {
    let date = parser(tmpl, ['date']).date;
    let d = new Date(date);
    if (date && isNaN(d.getTime()) === false) {
      return String(d.getFullYear())
    }
    return ''
  },

  'time ago': (tmpl) => {
    let time = parser(tmpl, ['date', 'fmt']).date;
    return timeSince(time)
  },
  'birth date': (tmpl, list) => {
    let obj = parser(tmpl, ['year', 'month', 'date']);
    list.push(obj);
    obj = ymd([obj.year, obj.month, obj.day]);
    return toText(obj)
  },
  //https://en.wikipedia.org/wiki/Template:Birth_date_and_age
  'birth date and age': (tmpl, list) => {
    let obj = parser(tmpl, ['year', 'month', 'day']);
    //support 'one property' version
    if (obj.year && /[a-z]/i.test(obj.year)) {
      return parsers.natural_date(tmpl, list)
    }
    list.push(obj);
    obj = ymd([obj.year, obj.month, obj.day]);
    return toText(obj)
  },
  'birth year and age': (tmpl, list) => {
    let obj = parser(tmpl, ['birth_year', 'birth_month']);
    //support 'one property' version
    if (obj.death_year && /[a-z]/i.test(obj.death_year)) {
      return parsers.natural_date(tmpl, list)
    }
    list.push(obj);
    let age = new Date().getFullYear() - parseInt(obj.birth_year, 10);
    obj = ymd([obj.birth_year, obj.birth_month]);
    let str = toText(obj);
    if (age) {
      str += ` (age ${age})`;
    }
    return str
  },
  'death year and age': (tmpl, list) => {
    let obj = parser(tmpl, ['death_year', 'birth_year', 'death_month']);
    //support 'one property' version
    if (obj.death_year && /[a-z]/i.test(obj.death_year)) {
      return parsers.natural_date(tmpl, list)
    }
    list.push(obj);
    obj = ymd([obj.death_year, obj.death_month]);
    return toText(obj)
  },
  //https://en.wikipedia.org/wiki/Template:Birth_date_and_age2
  'birth date and age2': (tmpl, list) => {
    let order = ['at_year', 'at_month', 'at_day', 'birth_year', 'birth_month', 'birth_day'];
    let obj = parser(tmpl, order);
    list.push(obj);
    obj = ymd([obj.birth_year, obj.birth_month, obj.birth_day]);
    return toText(obj)
  },
  //https://en.wikipedia.org/wiki/Template:Birth_based_on_age_as_of_date
  'birth based on age as of date': (tmpl, list) => {
    let obj = parser(tmpl, ['age', 'year', 'month', 'day']);
    list.push(obj);
    let age = parseInt(obj.age, 10);
    let year = parseInt(obj.year, 10);
    let born = year - age;
    if (born && age) {
      return `${born} (age ${obj.age})`
    }
    return `(age ${obj.age})`
  },
  //https://en.wikipedia.org/wiki/Template:Death_date_and_given_age
  'death date and given age': (tmpl, list) => {
    let obj = parser(tmpl, ['year', 'month', 'day', 'age']);
    list.push(obj);
    obj = ymd([obj.year, obj.month, obj.day]);
    let str = toText(obj);
    if (obj.age) {
      str += ` (age ${obj.age})`;
    }
    return str
  },
  //sortable dates -
  dts: (tmpl) => {
    //remove formatting stuff, ewww
    tmpl = tmpl.replace(/\|format=[ymd]+/i, '');
    tmpl = tmpl.replace(/\|abbr=(on|off)/i, '');
    let obj = parser(tmpl, ['year', 'month', 'date', 'bc']);
    if (obj.date && obj.month && obj.year) {
      //render 'june 5 2018'
      if (/[a-z]/.test(obj.month) === true) {
        return [obj.month, obj.date, obj.year].join(' ')
      }
      return [obj.year, obj.month, obj.date].join('-')
    }
    if (obj.month && obj.year) {
      return [obj.year, obj.month].join('-')
    }
    if (obj.year) {
      if (obj.year < 0) {
        obj.year = Math.abs(obj.year) + ' BC';
      }
      return obj.year
    }
    return ''
  },

  //we can't do timezones, so fake this one a little bit
  //https://en.wikipedia.org/wiki/Template:Time
  time: () => {
    let d = new Date();
    let obj = ymd([d.getFullYear(), d.getMonth(), d.getDate()]);
    return toText(obj)
  },

  // https://en.wikipedia.org/wiki/Template:MILLENNIUM
  millennium: (tmpl) => {
    let obj = parser(tmpl, ['year']);
    let year = parseInt(obj.year, 10);
    year = Math.floor(year / 1000) + 1;
    if (obj.abbr && obj.abbr === 'y') {
      if (year < 0) {
        return `${toOrdinal(Math.abs(year))} BC`
      }
      return `${toOrdinal(year)}`
    }
    return `${toOrdinal(year)} millennium`
  },
  //date/age/time templates
  start: parsers.date,
  'start-date': parsers.natural_date,
  birthdeathage: parsers.two_dates,
  age: parsers.age,
  'age nts': parsers.age,
  'age in years': parsers['diff-y'],
  'age in years and months': parsers['diff-ym'],
  'age in years, months and days': parsers['diff-ymd'],
  'age in years and days': parsers['diff-yd'],
  'age in days': parsers['diff-d'],
  // 'birth date and age2': date,
  // 'age in years, months, weeks and days': true,
  // 'age as of date': true,
};

/**
 * converts DMS (decimal-minute-second) geo format to lat/lng format.
 * major thank you to https://github.com/gmaclennan/parse-dms and https://github.com/WSDOT-GIS/dms-js 👏
 **/
function parseDMS(arr) {
  let hemisphere = arr.pop();
  let degrees = Number(arr[0] || 0);
  let minutes = Number(arr[1] || 0);
  let seconds = Number(arr[2] || 0);
  if (typeof hemisphere !== 'string' || isNaN(degrees)) {
    return null
  }
  let sign = 1;
  if (/[SW]/i.test(hemisphere)) {
    sign = -1;
  }
  return sign * (degrees + minutes / 60 + seconds / 3600)
}

const round = function (num) {
  if (typeof num !== 'number') {
    return num
  }
  let places = 100000;
  return Math.round(num * places) / places
};

//these hemispheres mean negative decimals
const negative = {
  s: true,
  w: true,
};

const findLatLng = function (arr) {
  const types = arr.map((s) => typeof s).join('|');
  //support {{lat|lng}}
  if (arr.length === 2 && types === 'number|number') {
    return {
      lat: arr[0],
      lon: arr[1],
    }
  }
  //support {{dd|N/S|dd|E/W}}
  if (arr.length === 4 && types === 'number|string|number|string') {
    if (negative[arr[1].toLowerCase()]) {
      arr[0] *= -1;
    }
    if (arr[3].toLowerCase() === 'w') {
      arr[2] *= -1;
    }
    return {
      lat: arr[0],
      lon: arr[2],
    }
  }
  //support {{dd|mm|N/S|dd|mm|E/W}}
  if (arr.length === 6) {
    return {
      lat: parseDMS(arr.slice(0, 3)),
      lon: parseDMS(arr.slice(3)),
    }
  }
  //support {{dd|mm|ss|N/S|dd|mm|ss|E/W}}
  if (arr.length === 8) {
    return {
      lat: parseDMS(arr.slice(0, 4)),
      lon: parseDMS(arr.slice(4)),
    }
  }
  return {}
};

const parseParams = function (obj) {
  obj.list = obj.list || [];
  obj.list = obj.list.map((str) => {
    let num = Number(str);
    if (!isNaN(num)) {
      return num
    }
    //these are weird
    let split = str.split(/:/);
    if (split.length > 1) {
      obj.props = obj.props || {};
      obj.props[split[0]] = split.slice(1).join(':');
      return null
    }
    return str
  });
  obj.list = obj.list.filter((s) => s !== null);
  return obj
};

const parseCoor = function (tmpl) {
  let obj = parser(tmpl);
  obj = parseParams(obj);
  let tmp = findLatLng(obj.list);
  obj.lat = round(tmp.lat);
  obj.lon = round(tmp.lon);
  obj.template = 'coord';
  delete obj.list;
  return obj
};
// {{Coor title dms|dd|mm|ss|N/S|dd|mm|ss|E/W|template parameters}}
// {{Coor title dec|latitude|longitude|template parameters}}
// {{Coor dms|dd|mm|ss|N/S|dd|mm|ss|E/W|template parameters}}
// {{Coor dm|dd|mm|N/S|dd|mm|E/W|template parameters}}
// {{Coor dec|latitude|longitude|template parameters}}

// {{coord|latitude|longitude|coordinate parameters|template parameters}}
// {{coord|dd|N/S|dd|E/W|coordinate parameters|template parameters}}
// {{coord|dd|mm|N/S|dd|mm|E/W|coordinate parameters|template parameters}}
// {{coord|dd|mm|ss|N/S|dd|mm|ss|E/W|coordinate parameters|template parameters}}

const templates$1 = {
  coord: (tmpl, list) => {
    let obj = parseCoor(tmpl);
    list.push(obj);
    //display inline, by default
    if (!obj.display || obj.display.indexOf('inline') !== -1) {
      return `${obj.lat || ''}°N, ${obj.lon || ''}°W`
    }
    return ''
  },
};

const generic = function (tmpl, list, _parser, alias) {
  let obj = parser(tmpl);
  if (alias) {
    obj.name = obj.template;
    obj.template = alias;
  }
  list.push(obj);
  return ''
};
// it may seem redundant,
// but we need these templates for our i18n mappings
const misc = {
  persondata: generic,
  taxobox: generic,
  citation: generic,
  portal: generic,
  reflist: generic,
  'cite book': generic,
  'cite journal': generic,
  'cite web': generic,
  'commons cat': generic,
  'election box candidate': generic,
  'election box begin': generic,
  main: generic,
};

const codes = {
  adx: 'adx', //https://en.wikipedia.org/wiki/Template:Abu_Dhabi_Securities_Exchange
  aim: 'aim', //https://en.wikipedia.org/wiki/Template:Alternative_Investment_Market
  amex: 'amex', //https://en.wikipedia.org/wiki/Template:NYSE_American
  asx: 'asx', //https://en.wikipedia.org/wiki/Template:Australian_Securities_Exchange
  athex: 'athex', //https://en.wikipedia.org/wiki/Template:Athens_Exchange
  b3: 'b3', //https://en.wikipedia.org/wiki/Template:BM%26F_Bovespa (redirects to B3 (stock exchange))
  'B3 (stock exchange)': 'B3 (stock exchange)', //https://en.wikipedia.org/wiki/Template:B3_(stock_exchange)
  barbadosse: 'barbadosse', //https://en.wikipedia.org/wiki/Template:Barbados_Stock_Exchange
  bbv: 'bbv', //https://en.wikipedia.org/wiki/Template:La_Paz_Stock_Exchange
  bcba: 'bcba', //https://en.wikipedia.org/wiki/Template:Buenos_Aires_Stock_Exchange
  bcs: 'bcs', //https://en.wikipedia.org/wiki/Template:Santiago_Stock_Exchange
  bhse: 'bhse', //https://en.wikipedia.org/wiki/Template:Bahrain_Bourse
  bist: 'bist', //https://en.wikipedia.org/wiki/Template:Borsa_Istanbul
  bit: 'bit', //https://en.wikipedia.org/wiki/Template:Borsa_Italiana
  'bm&f bovespa': 'b3', //https://en.wikipedia.org/wiki/Template:BM%26F_Bovespa
  'bm&f': 'b3', //https://en.wikipedia.org/wiki/Template:BM%26F_Bovespa
  bmad: 'bmad', //https://en.wikipedia.org/wiki/Template:Bolsa_de_Madrid
  bmv: 'bmv', //https://en.wikipedia.org/wiki/Template:Mexican_Stock_Exchange
  'bombay stock exchange': 'bombay stock exchange', //https://en.wikipedia.org/wiki/Template:Bombay_Stock_Exchange
  'botswana stock exchange': 'botswana stock exchange', //https://en.wikipedia.org/wiki/Template:BM%26F_Bovespa
  bpse: 'bpse', //https://en.wikipedia.org/wiki/Template:Budapest_Stock_Exchange
  bse: 'bse', //https://en.wikipedia.org/wiki/Template:Bombay_Stock_Exchange
  bsx: 'bsx', //https://en.wikipedia.org/wiki/Template:Bermuda_Stock_Exchange
  bvb: 'bvb', //https://en.wikipedia.org/wiki/Template:Bucharest_Stock_Exchange
  bvc: 'bvc', //https://en.wikipedia.org/wiki/Template:Colombian_Securities_Exchange
  bvl: 'bvl', //https://en.wikipedia.org/wiki/Template:Lima_Stock_Exchange
  bvpasa: 'bvpasa', //https://en.wikipedia.org/wiki/Template:BVPASA
  bwse: 'bwse', //https://en.wikipedia.org/wiki/Template:Botswana_Stock_Exchange
  'canadian securities exchange': 'canadian securities exchange', //https://en.wikipedia.org/wiki/Template:Canadian_Securities_Exchange
  cse: 'cse', //https://en.wikipedia.org/wiki/Template:Chittagong_Stock_Exchange
  darse: 'darse', //https://en.wikipedia.org/wiki/Template:Dar_es_Salaam_Stock_Exchange
  dfm: 'dfm', //https://en.wikipedia.org/wiki/Template:Dubai_Financial_Market
  dse: 'dse', //https://en.wikipedia.org/wiki/Template:Dhaka_Stock_Exchange
  euronext: 'euronext', //https://en.wikipedia.org/wiki/Template:Euronext
  euronextparis: 'euronextparis', //https://en.wikipedia.org/wiki/Template:EuronextParis
  fse: 'fse', //https://en.wikipedia.org/wiki/Template:Fukuoka_Stock_Exchange
  fwb: 'fwb', //https://en.wikipedia.org/wiki/Template:Frankfurt_Stock_Exchange
  gse: 'gse', //https://en.wikipedia.org/wiki/Template:Ghana_Stock_Exchange
  gtsm: 'gtsm', //https://en.wikipedia.org/wiki/Template:Gre_Tai_Securities_Market
  idx: 'idx', //https://en.wikipedia.org/wiki/Template:Indonesia_Stock_Exchange
  ise: 'ise', //https://en.wikipedia.org/wiki/Template:Irish_Stock_Exchange
  iseq: 'iseq', //https://en.wikipedia.org/wiki/Template:Irish_Stock_Exchange
  isin: 'isin', //https://en.wikipedia.org/wiki/Template:ISIN
  jasdaq: 'jasdaq', //https://en.wikipedia.org/wiki/Template:JASDAQ
  jse: 'jse', //https://en.wikipedia.org/wiki/Template:Johannesburg_Stock_Exchange
  kase: 'kase', //https://en.wikipedia.org/wiki/Template:Kazakhstan_Stock_Exchange
  kn: 'kn', //https://en.wikipedia.org/wiki/Template:Nairobi_Securities_Exchange
  krx: 'krx', //https://en.wikipedia.org/wiki/Template:Korea_Exchange
  lse: 'lse', //https://en.wikipedia.org/wiki/Template:London_Stock_Exchange
  luxse: 'luxse', //https://en.wikipedia.org/wiki/Template:Luxembourg_Stock_Exchange
  'malta stock exchange': 'malta stock exchange', //https://en.wikipedia.org/wiki/Template:Malta_Stock_Exchange
  mai: 'mai', //https://en.wikipedia.org/wiki/Template:Market_for_Alternative_Investment
  mcx: 'mcx', //https://en.wikipedia.org/wiki/Template:Moscow_Exchange
  mutf: 'mutf', //https://en.wikipedia.org/wiki/Template:Mutual_fund
  myx: 'myx', //https://en.wikipedia.org/wiki/Template:Bursa_Malaysia
  nag: 'nag', //https://en.wikipedia.org/wiki/Template:Nagoya_Stock_Exchange
  'nasdaq dubai': 'nasdaq dubai', //https://en.wikipedia.org/wiki/Template:NASDAQ_Dubai
  nasdaq: 'nasdaq', //https://en.wikipedia.org/wiki/Template:NASDAQ
  neeq: 'neeq', //https://en.wikipedia.org/wiki/Template:NEEQ
  nepse: 'nepse', //https://en.wikipedia.org/wiki/Template:Nepal_Stock_Exchange
  nex: 'nex', //https://en.wikipedia.org/wiki/Template:TSXV_NEX
  nse: 'nse', //https://en.wikipedia.org/wiki/Template:National_Stock_Exchange_of_India
  newconnect: 'newconnect', //https://en.wikipedia.org/wiki/Template:NewConnect
  'nyse arca': 'nyse arca', //https://en.wikipedia.org/wiki/Template:NYSE_Arca
  nyse: 'nyse', //https://en.wikipedia.org/wiki/Template:New_York_Stock_Exchange
  nzx: 'nzx', //https://en.wikipedia.org/wiki/Template:New_Zealand_Exchange
  'omx baltic': 'omx baltic', //https://en.wikipedia.org/wiki/Template:OMX_Baltic
  omx: 'omx', //https://en.wikipedia.org/wiki/Template:OMX
  ose: 'ose', //https://en.wikipedia.org/wiki/Template:Oslo_Stock_Exchange
  'otc expert': 'otc expert', //https://en.wikipedia.org/wiki/Template:OTC_Expert
  'otc grey': 'otc grey', //https://en.wikipedia.org/wiki/template:grey_market
  'otc pink': 'otc pink', //https://en.wikipedia.org/wiki/Template:OTC_Pink
  otcqb: 'otcqb', //https://en.wikipedia.org/wiki/Template:OTCQB
  otcqx: 'otcqx', //https://en.wikipedia.org/wiki/Template:OTCQX
  'pfts ukraine stock exchange': 'pfts ukraine stock exchange', //https://en.wikipedia.org/wiki/Template:PFTS_Ukraine_Stock_Exchange
  'philippine stock exchange': 'philippine stock exchange', //https://en.wikipedia.org/wiki/Template:Philippine_Stock_Exchange
  prse: 'prse', //https://en.wikipedia.org/wiki/Template:Prague_Stock_Exchange
  psx: 'psx', //https://en.wikipedia.org/wiki/Template:Pakistan_Stock_Exchange
  karse: 'karse', //https://en.wikipedia.org/w/index.php?title=Template:Karse&redirect=no (redirects to psx)
  qe: 'qe', //https://en.wikipedia.org/wiki/Template:Qatar_Stock_Exchange
  'saudi stock exchange': 'saudi stock exchange', //https://en.wikipedia.org/wiki/Template:Saudi_Stock_Exchange
  sehk: 'sehk', //https://en.wikipedia.org/wiki/Template:Hong_Kong_Stock_Exchange
  'Stock Exchange of Thailand': 'Stock Exchange of Thailand', //https://en.wikipedia.org/wiki/Template:Stock_Exchange_of_Thailand (alternative for SET)
  set: 'set', //https://en.wikipedia.org/wiki/Template:Stock_Exchange_of_Thailand
  sgx: 'sgx', //https://en.wikipedia.org/wiki/Template:Singapore_Exchange
  sse: 'sse', //https://en.wikipedia.org/wiki/Template:Shanghai_Stock_Exchange
  swx: 'swx', //https://en.wikipedia.org/wiki/Template:SIX_Swiss_Exchange
  szse: 'szse', //https://en.wikipedia.org/wiki/Template:Shenzhen_Stock_Exchange
  tase: 'tase', //https://en.wikipedia.org/wiki/Template:Tel_Aviv_Stock_Exchange
  'tsx-v': 'tsx-v', //https://en.wikipedia.org/wiki/Template:TSX_Venture_Exchange
  tsx: 'tsx', //https://en.wikipedia.org/wiki/Template:Toronto_Stock_Exchange
  tsxv: 'tsxv', //https://en.wikipedia.org/wiki/Template:TSX_Venture_Exchange
  ttse: 'ttse', //https://en.wikipedia.org/wiki/Template:Trinidad_and_Tobago_Stock_Exchange
  twse: 'twse', //https://en.wikipedia.org/wiki/Template:Taiwan_Stock_Exchange
  tyo: 'tyo', //https://en.wikipedia.org/wiki/Template:Tokyo_Stock_Exchange
  wbag: 'wbag', //https://en.wikipedia.org/wiki/Template:Wiener_B%C3%B6rse
  wse: 'wse', //https://en.wikipedia.org/wiki/Template:Warsaw_Stock_Exchange
  'zagreb stock exchange': 'zagreb stock exchange', //https://en.wikipedia.org/wiki/Template:Zagreb_Stock_Exchange
  'zimbabwe stock exchange': 'zimbabwe stock exchange', //https://en.wikipedia.org/wiki/Template:Zimbabwe_Stock_Exchange
  zse: 'zse', //https://en.wikipedia.org/wiki/Template:Zagreb_Stock_Exchange
};

const parseStockExchange = (tmpl, list) => {
  let o = parser(tmpl, ['ticketnumber', 'code']);
  list.push(o);
  let code = o.template || '';
  if (code === '') {
    code = o.code;
  }
  code = (code || '').toLowerCase();
  let str = codes[code] || '';
  if (o.ticketnumber) {
    str = `${str}: ${o.ticketnumber}`;
  }
  if (o.code && !codes[o.code.toLowerCase()]) {
    str += ' ' + o.code;
  }
  return str
};

const exchanges = {};
//the others fit the same pattern..
Object.keys(codes).forEach((k) => {
  exchanges[k] = parseStockExchange;
});

const zeroPad = function (num) {
  num = String(num);
  if (num.length === 1) {
    num = '0' + num;
  }
  return num
};

const parseTeam = function (obj, round, team) {
  if (obj[`rd${round}-team${zeroPad(team)}`]) {
    team = zeroPad(team);
  }
  let score = obj[`rd${round}-score${team}`];
  let num = Number(score);
  if (isNaN(num) === false) {
    score = num;
  }
  return {
    team: obj[`rd${round}-team${team}`],
    score: score,
    seed: obj[`rd${round}-seed${team}`],
  }
};

// https://en.wikipedia.org/wiki/Category:Tournament_bracket_templates
//these are weird.
const playoffBracket = function (tmpl) {
  let rounds = [];
  let obj = parser(tmpl);
  //try some rounds
  for (let i = 1; i < 7; i += 1) {
    let round = [];
    for (let t = 1; t < 16; t += 2) {
      let key = `rd${i}-team`;
      if (obj[key + t] || obj[key + zeroPad(t)]) {
        let one = parseTeam(obj, i, t);
        let two = parseTeam(obj, i, t + 1);
        round.push([one, two]);
      } else {
        break
      }
    }
    if (round.length > 0) {
      rounds.push(round);
    }
  }
  return {
    template: 'playoffbracket',
    rounds: rounds,
  }
};

let sports = {
  //playoff brackets
  '4teambracket': function (tmpl, list) {
    let obj = playoffBracket(tmpl);
    list.push(obj);
    return ''
  },


  player: (tmpl, list) => {
    let res = parser(tmpl, ['number', 'country', 'name', 'dl']);
    list.push(res);
    let str = `[[${res.name}]]`;
    if (res.country) {
      let country = (res.country || '').toLowerCase();
      let flag = flags.find((a) => country === a[1] || country === a[2]) || [];
      if (flag && flag[0]) {
        str = flag[0] + '  ' + str;
      }
    }
    if (res.number) {
      str = res.number + ' ' + str;
    }
    return str
  },

  //https://en.wikipedia.org/wiki/Template:Goal
  goal: (tmpl, list) => {
    let res = parser(tmpl);
    let obj = {
      template: 'goal',
      data: [],
    };
    let arr = res.list || [];
    for (let i = 0; i < arr.length; i += 2) {
      obj.data.push({
        min: arr[i],
        note: arr[i + 1] || '',
      });
    }
    list.push(obj);
    //generate a little text summary
    let summary = '⚽ ';
    summary += obj.data
      .map((o) => {
        let note = o.note;
        if (note) {
          note = ` (${note})`;
        }
        return o.min + "'" + note
      })
      .join(', ');
    return summary
  },

  //a transcluded sports module - https://en.m.wikipedia.org/w/index.php?title=Special:WhatLinksHere/Module:Sports_table
  // https://en.wikipedia.org/wiki/Template:2020–21_NHL_North_Division_standings
  'sports table': (tmpl, list) => {
    let obj = parser(tmpl);
    let byTeam = {};
    let teams = Object.keys(obj)
      .filter((k) => /^team[0-9]/.test(k))
      .map((k) => obj[k].toLowerCase());
    teams.forEach((team) => {
      byTeam[team] = {
        name: obj[`name_${team}`],
        win: Number(obj[`win_${team}`]) || 0,
        loss: Number(obj[`loss_${team}`]) || 0,
        tie: Number(obj[`tie_${team}`]) || 0,
        otloss: Number(obj[`otloss_${team}`]) || 0,
        goals_for: Number(obj[`gf_${team}`]) || 0,
        goals_against: Number(obj[`ga_${team}`]) || 0,
      };
    });
    let res = {
      date: obj.update,
      header: obj.table_header,
      teams: byTeam,
    };
    list.push(res);
  },

  // college baseketball rosters
  'cbb roster/header': function () {
    return `{| class="wikitable"
    |-
    ! POS
    ! #
    ! Name
    ! Height
    ! Weight
    ! Year
    ! Previous School
    ! Hometown
    |-\n`
  },
  'cbb roster/player': function (tmpl, list) {
    let data = parser(tmpl);
    list.push(data);
    // first=|last=|dab=|num=|pos=|ft=|in=|lbs=|class=|rs=|home=
    return `|-
| ${data.pos || ''}
| ${data.num || ''}
| ${data.first || ''} ${data.last || ''}
| ${data.ft || ''}${data.in || ''}
| ${data.lbs || ''}
| ${data.class || ''}
| ${data.high_school || ''}
| ${data.home || ''}
`
  },
  'cbb roster/footer': function () {
    return `\n|}`
  },
};

var bothTmpl = Object.assign(
  {},
  shorthand,
  templates$3,
  templates$2,
  dates,
  templates$1,
  misc,
  exchanges,
  playoffBracket,
  sports,
);

let templates = Object.assign({}, textTmpl, dataTmpl, bothTmpl);

Object.keys(aliases).forEach((k) => {
  if (templates[aliases[k]] === undefined) {
    console.error(`Missing template: '${aliases[k]}'`);
  }
  templates[k] = templates[aliases[k]];
});

// console.log(Object.keys(templates).length)

const nums = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];

//this gets all the {{template}} objects and decides how to parse them
const parseTemplate = function (tmpl, doc) {
  let name = tmpl.name;
  // dont bother with some junk templates
  if (ignore.hasOwnProperty(name) === true) {
    return ['']
  }
  //{{infobox settlement...}}
  if (isInfobox(name) === true) {
    let obj = parser(tmpl.body, [], 'raw');
    // list.push(infobox.format(obj))
    return ['', fmtInfobox(obj)]
  }
  //cite book, cite arxiv...
  if (/^cite [a-z]/.test(name) === true) {
    let obj = parser(tmpl.body);
    obj.type = obj.template;
    obj.template = 'citation';
    // list.push(obj)
    return ['', obj]
  }
  // ok, here we go!
  //parse some known templates
  if (templates.hasOwnProperty(name) === true) {
    //handle number-syntax
    if (typeof templates[name] === 'number') {
      let obj = parser(tmpl.body, nums);
      let key = String(templates[name]);
      return [obj[key] || '']
    }
    //handle string-syntax
    if (typeof templates[name] === 'string') {
      return [templates[name]]
    }
    //handle array sytax
    if (isArray(templates[name]) === true) {
      let obj = parser(tmpl.body, templates[name]);
      // list.push(obj)
      return ['', obj]
    }
    //handle object sytax
    if (isObject(templates[name]) === true) {
      let obj = parser(tmpl.body, templates[name].props);
      // list.push(obj)
      return [obj[templates[name].out], obj]
    }
    //handle function syntax
    if (typeof templates[name] === 'function') {
      // let json = toJSON(tmpl.body)
      //(tmpl, list, alias, doc)
      let arr = [];
      let txt = templates[name](tmpl.body, arr, parser, null, doc);
      return [txt, arr[0]]
    }
  }
  //if set, try using the global template fallback parser
  if (doc && doc._templateFallbackFn) {
    let arr = [];
    let txt = doc._templateFallbackFn(tmpl.body, arr, parser, null, doc);
    if (txt !== null) {
      return [txt, arr[0]]
    }
  }
  //an unknown template with data, so just keep it.
  let json = parser(tmpl.body);
  if (Object.keys(json).length === 0) {
    // list.push(json)
    json = null;
  }
  //..then remove it
  return ['', json]
};

/**
 * turn an infobox into some nice json
 * 
 * @param {object} infobox 
 * @param {object} [options] 
 * @returns {object}
 */
const toJson = function (infobox, options) {
  let json = Object.keys(infobox.data).reduce((h, k) => {
    if (infobox.data[k]) {
      h[k] = infobox.data[k].json();
    }
    return h
  }, {});

  //support mongo-encoding keys
  if (options.encode === true) {
    json = encodeObj(json);
  }
  return json
};

const normalize = (str = '') => {
  str = str.toLowerCase();
  str = str.replace(/[-_]/g, ' ');
  return str.trim()
};

//a formal key-value data table about a topic
const Infobox = function (obj, wiki) {
  this._type = obj.type;
  this.domain = obj.domain;
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: obj.data,
  });
  Object.defineProperty(this, 'wiki', {
    enumerable: false,
    value: wiki,
  });
};

const methods$2 = {
  type: function () {
    return this._type
  },
  links: function (n) {
    let arr = [];
    Object.keys(this.data).forEach((k) => {
      this.data[k].links().forEach((l) => arr.push(l));
    });
    if (typeof n === 'string') {
      //grab a link like .links('Fortnight')
      n = n.charAt(0).toUpperCase() + n.substring(1); //titlecase it
      let link = arr.find((o) => o.page() === n);
      return link === undefined ? [] : [link]
    }
    return arr
  },
  image: function () {
    let s = this.data.image || this.data.image2 || this.data.logo || this.data.image_skyline || this.data.image_flag;
    if (!s) {
      return null
    }
    let obj = s.json();
    let file = obj.text;
    obj.file = file;
    obj.text = '';
    obj.caption = this.data.caption;
    obj.domain = this.domain; // add domain information for image
    return new Image(obj)
  },
  get: function (keys) {
    let allKeys = Object.keys(this.data);
    if (typeof keys === 'string') {
      let key = normalize(keys);
      for (let i = 0; i < allKeys.length; i += 1) {
        let tmp = normalize(allKeys[i]);
        if (key === tmp) {
          return this.data[allKeys[i]]
        }
      }
      return new Sentence()
    }
    if (isArray(keys)) {
      // support array-input
      keys = keys.map(normalize);
      return keys.map((k) => {
        for (let i = 0; i < allKeys.length; i += 1) {
          let tmp = normalize(allKeys[i]);
          if (k === tmp) {
            return this.data[allKeys[i]]
          }
        }
        return new Sentence()
      })
    }
    return new Sentence()
  },
  text: function () {
    return ''
  },
  json: function (options) {
    options = options || {};
    return toJson(this, options)
  },
  wikitext: function () {
    return this.wiki || ''
  },
  keyValue: function () {
    return Object.keys(this.data).reduce((h, k) => {
      if (this.data[k]) {
        h[k] = this.data[k].text();
      }
      return h
    }, {})
  },
};
//aliases
Object.keys(methods$2).forEach((k) => {
  Infobox.prototype[k] = methods$2[k];
});
Infobox.prototype.data = Infobox.prototype.keyValue;
Infobox.prototype.template = Infobox.prototype.type;
Infobox.prototype.images = Infobox.prototype.image;

//also called 'citations'
const Reference = function (data, wiki) {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
  Object.defineProperty(this, 'wiki', {
    enumerable: false,
    value: wiki,
  });
};

const methods$1 = {
  title: function () {
    let data = this.data;
    return data.title || data.encyclopedia || data.author || ''
  },
  links: function (n) {
    let arr = [];
    if (typeof n === 'number') {
      return arr[n]
    }
    //grab a specific link..
    if (typeof n === 'number') {
      return arr[n]
    } else if (typeof n === 'string') {
      //grab a link like .links('Fortnight')
      n = n.charAt(0).toUpperCase() + n.substring(1); //titlecase it
      let link = arr.find((o) => o.page() === n);
      return link === undefined ? [] : [link]
    }
    return arr || []
  },
  text: function () {
    return '' //nah, skip these.
  },
  wikitext: function () {
    return this.wiki || ''
  },
  json: function (options = {}) {
    let json = this.data || {};
    //encode them, for mongodb
    if (options.encode === true) {
      json = Object.assign({}, json);
      json = encodeObj(json);
    }
    return json
  },
};
Object.keys(methods$1).forEach((k) => {
  Reference.prototype[k] = methods$1[k];
});

const methods = {
  text: function () {
    let str = this._text || '';
    return fromText(str).text()
  },
  json: function () {
    return this.data || {}
  },
  wikitext: function () {
    return this.wiki || ''
  },
};

const Template = function (data, text = '', wiki = '') {
  Object.defineProperty(this, 'data', {
    enumerable: false,
    value: data,
  });
  Object.defineProperty(this, '_text', {
    enumerable: false,
    value: text,
  });
  Object.defineProperty(this, 'wiki', {
    enumerable: false,
    value: wiki,
  });
};

Object.keys(methods).forEach((k) => {
  Template.prototype[k] = methods[k];
});

const isCitation = /^(cite |citation)/i;

const referenceTypes = {
  citation: true,
  refn: true,
  harvnb: true,
  source: true, //wikinews
};

// split Infoboxes from templates and references
const sortOut = function (list, domain) {
  let res = {
    infoboxes: [],
    templates: [],
    references: [],
  };
  //remove references and infoboxes from our list
  list.forEach((obj) => {
    let json = obj.json;
    let kind = json.template || json.type || json.name;
    // is it a Reference?
    if (referenceTypes[kind] === true || isCitation.test(kind) === true) {
      res.references.push(new Reference(json, obj.wiki));
      return
    }
    // is it an Infobox?
    if (json.template === 'infobox' && json.subbox !== 'yes') {
      json.domain = domain; //infoboxes need this for images, i guess
      json.data = json.data || {}; //validate it a little
      res.infoboxes.push(new Infobox(json, obj.wiki));
      return
    }
    // otherwise, it's just a template
    res.templates.push(new Template(json, obj.text, obj.wiki));
  });
  return res
};

// return a flat list of all {{templates}}
const allTemplates = function (wiki, doc) {
  let list = [];
  //nested data-structure of templates
  let nested = findTemplates(wiki);
  //recursive template-parser
  const parseNested = function (obj, parent) {
    obj.parent = parent;
    //do tail-first recursion
    if (obj.children && obj.children.length > 0) {
      obj.children.forEach((ch) => parseNested(ch, obj));
    }
    //parse template into json, return replacement wikitext
    let [text, json] = parseTemplate(obj, doc);
    obj.wiki = text;
    if (json) {
      list.push({
        name: obj.name,
        wiki: obj.body,
        nested: Boolean(obj.parent),
        text: text,
        json: json,
      });
    }
    //remove the text from every parent
    const removeIt = function (node, body, out) {
      if (node.parent) {
        node.parent.body = node.parent.body.replace(body, out);
        removeIt(node.parent, body, out);
      }
    };
    removeIt(obj, obj.body, obj.wiki);
    wiki = wiki.replace(obj.body, obj.wiki);
  };
  //kick it off
  nested.forEach((node) => parseNested(node, null));
  //remove the templates from our wiki text
  nested.forEach((node) => {
    wiki = wiki.replace(node.body, node.wiki);
  });
  return { list: list, wiki: wiki }
};

//find + parse all templates in the section
const process = function (section, doc) {
  // find+parse them all
  let { list, wiki } = allTemplates(section._wiki, doc);
  // split-out references and infoboxes
  let domain = doc ? doc._domain : null;
  let { infoboxes, references, templates } = sortOut(list, domain);

  //sort-out the templates we decide to keep
  section._infoboxes = section._infoboxes || [];
  section._references = section._references || [];
  section._templates = section._templates || [];

  section._infoboxes = section._infoboxes.concat(infoboxes);
  section._references = section._references.concat(references);
  section._templates = section._templates.concat(templates);

  section._wiki = wiki;
};

//structured Cite templates - <ref>{{Cite..</ref>
const hasCitation = function (str) {
  return /^ *\{\{ *(cite|citation)/i.test(str) && /\}\} *$/.test(str) && /citation needed/i.test(str) === false
};

const parseCitation = function (tmpl) {
  let obj = parser(tmpl);
  obj.type = obj.template.replace(/cite /, '');
  obj.template = 'citation';
  return obj
};

//handle unstructured ones - <ref>some text</ref>
const parseInline = function (str) {
  let obj = fromText(str) || {};
  return {
    template: 'citation',
    type: 'inline',
    data: {},
    inline: obj,
  }
};

//parse <ref></ref> xml tags
const parseRefs = function (section) {
  let references = [];
  let wiki = section._wiki;

  wiki = wiki.replace(/ ?<ref>([\s\S]{0,1800}?)<\/ref> ?/gi, function (all, txt) {
    let found = false;
    // there could be more than 1 template inside a <ref><ref>
    let arr = findFlat(txt);
    arr.forEach((tmpl) => {
      if (hasCitation(tmpl)) {
        let obj = parseCitation(tmpl);
        if (obj) {
          references.push({ json: obj, wiki: all });
          found = true;
        }
        wiki = wiki.replace(tmpl, '');
      }
    });
    // parse as an inline reference
    if (!found) {
      references.push({ json: parseInline(txt), wiki: all });
    }
    return ' '
  });

  //<ref name=""/>
  wiki = wiki.replace(/ ?<ref [^>]{0,200}?\/> ?/gi, ' ');

  //<ref name=""></ref> (a gross copy of above parsing)
  wiki = wiki.replace(/ ?<ref [^>]{0,200}>([\s\S]{0,1800}?)<\/ref> ?/gi, function (all, txt) {
    let found = false;
    // there could be more than 1 template inside a <ref><ref>
    let arr = findFlat(txt);
    arr.forEach((tmpl) => {
      if (hasCitation(tmpl)) {
        let obj = parseCitation(tmpl);
        if (obj) {
          references.push({ json: obj, wiki: all });
          found = true;
        }
        wiki = wiki.replace(tmpl, '');
      }
    });
    // parse as an inline reference
    if (!found) {
      references.push({ json: parseInline(txt), wiki: all });
    }
    return ' '
  });

  //now that we're done with xml, do a generic + dangerous xml-tag removal
  wiki = wiki.replace(/ ?<[ /]?[a-z0-9]{1,8}[a-z0-9=" ]{2,20}[ /]?> ?/g, ' '); //<samp name="asd">
  section._references = references.map((obj) => new Reference(obj.json, obj.wiki));
  section._wiki = wiki;
};

//okay, <gallery> is a xml-tag, with newline-separated data, somehow pivoted by '|'...
//all deities help us. truly -> https://en.wikipedia.org/wiki/Help:Gallery_tag
//- not to be confused with https://en.wikipedia.org/wiki/Template:Gallery...
/**
 *
 * @private
 * @param {object} catcher
 * @param {object} doc
 * @param {object} section
 */
const parseGallery = function (catcher, doc, section) {
  catcher.text = catcher.text.replace(/<gallery([^>]*)>([\s\S]+)<\/gallery>/g, (_, _attrs, inside) => {
    let images = inside.split(/\n/g);
    images = images.filter((str) => str && str.trim() !== '');

    //parse the line, which has an image and sometimes a caption
    images = images.map((str) => {
      let arr = str.split(/\|/);
      let obj = {
        file: arr[0].trim(),
        lang: doc.lang(),
        domain: doc.domain(),
      };
      let img = new Image(obj).json();
      let caption = arr.slice(1).join('|');
      if (caption !== '') {
        img.caption = fromText(caption);
      }
      return img
    });

    //add it to our templates list
    if (images.length > 0) {
      catcher.templates.push({
        template: 'gallery',
        images: images,
        pos: section.title,
      });
    }

    //return empty string to remove the template from the wiki text
    return ''
  });
};

/**
 * parses out the `Election_box` template from the wiki text
 *
 * this is a non-traditional template, for some reason
 * https://en.wikipedia.org/wiki/Template:Election_box
 *
 * @private
 * @param {object} catcher an object to provide and catch data
 * @param {Document} doc
 */
const parseElection = function (catcher, doc) {
  catcher.text = catcher.text.replace(/\{\{election box begin([\s\S]+?)\{\{election box end\}\}/gi, (tmpl) => {
    let data = {
      _wiki: tmpl,
      _templates: [],
    };

    //put it through our full template parser..
    process(data, doc);

    //okay, pull it apart into something sensible..
    let templates = data._templates.map((t) => t.json());

    let start = templates.find((t) => t.template === 'election box') || {};
    let candidates = templates.filter((t) => t.template === 'election box candidate');
    let summary = templates.find((t) => t.template === 'election box gain' || t.template === 'election box hold') || {};

    if (candidates.length > 0 || summary) {
      catcher.templates.push({
        template: 'election box',
        title: start.title,
        candidates: candidates,
        summary: summary.data,
      });
    }

    //return empty string to remove the template from the wiki text
    return ''
  });
};

const keys = {
  coach: ['team', 'year', 'g', 'w', 'l', 'w-l%', 'finish', 'pg', 'pw', 'pl', 'pw-l%'],
  player: ['year', 'team', 'gp', 'gs', 'mpg', 'fg%', '3p%', 'ft%', 'rpg', 'apg', 'spg', 'bpg', 'ppg'],
  roster: ['player', 'gp', 'gs', 'mpg', 'fg%', '3fg%', 'ft%', 'rpg', 'apg', 'spg', 'bpg', 'ppg'],
};

/**
 * https://en.wikipedia.org/wiki/Template:NBA_player_statistics_start
 *
 * @private
 * @param {object} catcher
 */
const parseNBA = function (catcher) {
  catcher.text = catcher.text.replace(
    /\{\{nba (coach|player|roster) statistics start([\s\S]+?)\{\{s-end\}\}/gi,
    (tmpl, name) => {
      tmpl = tmpl.replace(/^\{\{.*?\}\}/, '');
      tmpl = tmpl.replace(/\{\{s-end\}\}/, '');
      name = name.toLowerCase().trim();

      let headers = '! ' + keys[name].join(' !! ');
      let table = '{|\n' + headers + '\n' + tmpl + '\n|}';
      let rows = parseTable(table);
      rows = rows.map((row) => {
        Object.keys(row).forEach((k) => {
          row[k] = row[k].text();
        });
        return row
      });

      catcher.templates.push({
        template: 'NBA ' + name + ' statistics',
        data: rows,
      });

      //return empty string to remove the template from the wiki text
      return ''
    }
  );
};

//https://en.wikipedia.org/wiki/Template:MLB_game_log_section

//this is pretty nuts
const whichHeadings = function (tmpl) {
  let headings = ['#', 'date', 'opponent', 'score', 'win', 'loss', 'save', 'attendance', 'record'];
  if (/\|stadium=y/i.test(tmpl) === true) {
    headings.splice(7, 0, 'stadium'); //save, stadium, attendance
  }
  if (/\|time=y/i.test(tmpl) === true) {
    headings.splice(7, 0, 'time'); //save, time, stadium, attendance
  }
  if (/\|box=y/i.test(tmpl) === true) {
    headings.push('box'); //record, box
  }
  return headings
};
/**
 *
 * @private
 * @param {object} catcher
 */
const parseMlb = function (catcher) {
  catcher.text = catcher.text.replace(/\{\{mlb game log /gi, '{{game log ');
  catcher.text = catcher.text.replace(/\{\{game log (section|month)[\s\S]+?\{\{game log (section|month) end\}\}/gi, (tmpl) => {
    let headings = whichHeadings(tmpl);

    tmpl = tmpl.replace(/^\{\{.*?\}\}/, '');
    tmpl = tmpl.replace(/\{\{game log (section|month) end\}\}/i, '');

    let headers = '! ' + headings.join(' !! ');
    let table = '{|\n' + headers + '\n' + tmpl + '\n|}';
    let rows = parseTable(table);
    rows = rows.map((row) => {
      Object.keys(row).forEach((k) => {
        row[k] = row[k].text();
      });
      return row
    });
    catcher.templates.push({
      template: 'mlb game log section',
      data: rows,
    });

    //return empty string to remove the template from the wiki text
    return ''
  }
  );
};

let headings = ['res', 'record', 'opponent', 'method', 'event', 'date', 'round', 'time', 'location', 'notes'];

/**
 *
 * https://en.wikipedia.org/wiki/Template:MMA_record_start
 *
 * @private
 * @param {object} catcher
 */
const parseMMA = function (catcher) {
  catcher.text = catcher.text.replace(/\{\{mma record start[\s\S]+?\{\{end\}\}/gi, (tmpl) => {
    tmpl = tmpl.replace(/^\{\{.*?\}\}/, '');
    tmpl = tmpl.replace(/\{\{end\}\}/i, '');

    let headers = '! ' + headings.join(' !! ');
    let table = '{|\n' + headers + '\n' + tmpl + '\n|}';
    let rows = parseTable(table);
    rows = rows.map((row) => {
      Object.keys(row).forEach((k) => {
        row[k] = row[k].text();
      });
      return row
    });

    catcher.templates.push({
      template: 'mma record start',
      data: rows,
    });

    //return empty string to remove the template from the wiki text
    return ''
  });
};

/**
 * try to parse out the math and chem templates
 *
 * xml <math>y=mx+b</math> support
 * https://en.wikipedia.org/wiki/Help:Displaying_a_formula
 *
 * @private
 * @param {object} catcher
 */
const parseMath = function (catcher) {
  catcher.text = catcher.text.replace(/<math([^>]*)>([\s\S]*?)<\/math>/g, (_, attrs, inside) => {
    //clean it up a little?
    let formula = fromText(inside).text();
    catcher.templates.push({
      template: 'math',
      formula: formula,
      raw: inside,
    });

    //should we at least try to render it in plaintext? :/
    if (formula && formula.length < 12) {
      return formula
    }

    //return empty string to remove the template from the wiki text
    return ''
  });

  //try chemistry version too
  catcher.text = catcher.text.replace(/<chem([^>]*)>([\s\S]*?)<\/chem>/g, (_, attrs, inside) => {
    catcher.templates.push({
      template: 'chem',
      data: inside,
    });

    //return empty string to remove the template from the wiki text
    return ''
  });
};

/**
 * parses out non standard templates
 *
 * Most templates are '{{template}}',
 * but then, some are '<template></template>' others are {{start}}...{{end}}
 * -> the templates here are of the second type.
 *
 * @private
 * @param {object} section
 * @param {object} doc
 * @returns {Object} wikitext
 */
const xmlTemplates = function (section, doc) {
  const res = {
    templates: [],
    text: section._wiki,
  };

  parseElection(res, doc);
  parseGallery(res, doc, section);
  parseMath(res);
  parseMlb(res);
  parseMMA(res);
  parseNBA(res);

  // turn them into Template objects
  res.templates = res.templates.map((obj) => new Template(obj));
  return res
};

const defaults$2 = {
  tables: true,
  references: true,
  paragraphs: true,
  templates: true,
  infoboxes: true,
};

/**
 * the Section class represents the different sections of the article.
 * we look for the == title == syntax and split and parse the sections from there
 *
 * @class
 */
class Section {
  /**
   * the stuff between headings - 'History' section for example
   *
   * @param {object} data the data already gathered about the section
   * @param {object} doc the document that this section belongs to
   */
  constructor(data, doc) {
    let props = {
      doc: doc,
      title: data.title || '',
      depth: data.depth,
      wiki: data.wiki || '',
      templates: [],
      tables: [],
      infoboxes: [],
      references: [],
      paragraphs: [],
    };
    Object.keys(props).forEach((k) => {
      Object.defineProperty(this, '_' + k, {
        enumerable: false,
        writable: true,
        value: props[k],
      });
    });

    //parse-out <template></template>' and {{start}}...{{end}} templates
    const startEndTemplates = xmlTemplates(this, doc);
    this._wiki = startEndTemplates.text;
    this._templates = this._templates.concat(startEndTemplates.templates);

    //parse-out the <ref></ref> tags
    parseRefs(this);
    //parse-out all {{templates}}
    process(this, doc);

    //parse the tables
    findTables(this);

    //now parse all double-newlines
    parseParagraphs(this, doc);
  }

  /**
   * returns the title of a section. if no title is available then it returns empty string
   *
   * @returns {string} the title of the section
   */
  title() {
    return this._title || ''
  }

  /**
   * returns the index of the current section in the document
   *
   * @returns {number | null} the index of the current section in the document
   */
  index() {
    if (!this._doc) {
      return null
    }
    let index = this._doc.sections().indexOf(this);
    if (index === -1) {
      return null
    }
    return index
  }

  /**
   * returns the depth (or indentation) of the section
   * aka how many levels deep is this section located
   *
   * @returns {number} the depth of the section
   */
  depth() {
    return this._depth
  }

  /**
   * returns the depth (or indentation) of the section
   * aka how many levels deep is this section located
   *
   * @returns {number} the depth of the section
   */
  indentation() {
    return this.depth()
  }

  /**
   * returns all sentences in the section
   * if an clue is provided then it returns the sentence at clue-th index
   *
   * @returns {object | object[]} all sentences in an array or the clue-th sentence
   */
  sentences() {
    return this.paragraphs().reduce((list, p) => {
      return list.concat(p.sentences())
    }, [])
  }

  /**
   * returns all paragraphs in the section
   * if an clue is provided then it returns the paragraph at clue-th index
   *
   * @returns {object | object[]} all paragraphs in an array or the clue-th paragraph
   */
  paragraphs() {
    return this._paragraphs || []
  }

  /**
   * returns all links in the section
   * if an clue is provided and it is a number then it returns the link at clue-th index
   * if an clue is provided and it is a string then it returns the link at the that content
   *
   * @param {number| string} [clue] the clue for selecting the link
   * @returns {object | object[]} all links in an array or the clue-th link or the link with the content of clue
   */
  links(clue) {
    let arr = [];

    this.infoboxes().forEach((templ) => {
      arr.push(templ.links());
    });

    this.sentences().forEach((s) => {
      arr.push(s.links());
    });

    this.tables().forEach((t) => {
      arr.push(t.links());
    });

    this.lists().forEach((list) => {
      arr.push(list.links());
    });

    arr = arr
      .reduce((acc, val) => acc.concat(val), []) //flatten the array
      .filter((val) => val !== undefined); //filter out all the undefined from the flattened empty arrays

    if (typeof clue === 'string') {
      let link = arr.find((o) => o.page().toLowerCase() === clue.toLowerCase());
      return link === undefined ? [] : [link]
    }

    return arr
  }

  /**
   * returns all tables in the section
   * if an clue is provided then it returns the table at clue-th index
   *
   * @returns {object | object[]} all tables in an array or the clue-th infobox
   */
  tables() {
    return this._tables || []
  }

  /**
   * returns all templates in the section
   * if an clue is provided and clue is a number then it returns the template at clue-th index
   * if an clue is provided and clue is a string then it returns all template with that name
   *
   * @param {number|string} [clue] the clue for selecting the template
   * @returns {object | object[]} all templates in an array or the clue-th template or all template name `clue`
   */
  templates(clue) {
    let arr = this._templates || [];
    // arr = arr.map((t) => t.json())
    if (typeof clue === 'string') {
      clue = clue.toLowerCase();
      return arr.filter((o) => o.data.template === clue || o.data.name === clue)
    }

    return arr
  }

  /**
   * returns all infoboxes in the section
   * if an clue is provided then it returns the infobox at clue-th index
   *
   * @param {number|string} [clue] the clue for selecting the infobox
   * @returns {object | object[]} all infoboxes in an array or the clue-th infobox
   */
  infoboxes(clue) {
    let arr = this._infoboxes || [];
    if (typeof clue === 'string') {
      clue = clue.replace(/^infobox /i, '');
      clue = clue.trim().toLowerCase();
      return arr.filter((info) => info._type === clue)
    }
    return arr
  }

  /**
   * returns all lists in the section
   * if an clue is provided then it returns the list at clue-th index
   *
   * @returns {object | object[]} all lists in an array or the clue-th list
   */
  coordinates() {
    let arr = [...this.templates('coord'), ...this.templates('coor')];
    return arr.map((tmpl) => tmpl.json())
  }

  /**
   * returns all lists in the section
   * if an clue is provided then it returns the list at clue-th index
   *
   * @returns {object | object[]} all lists in an array or the clue-th list
   */
  lists() {
    let arr = [];
    this.paragraphs().forEach((p) => {
      arr = arr.concat(p.lists());
    });
    return arr
  }

  /**
   * returns all interwiki links in the section
   * if an clue is provided then it returns the interwiki link at clue-th index
   *
   * @returns {object | object[]} all interwiki links in an array or the clue-th interwiki link
   */
  interwiki() {
    let arr = [];
    this.paragraphs().forEach((p) => {
      arr = arr.concat(p.interwiki());
    });
    return arr
  }

  /**
   * returns all images in the section
   * if an clue is provided then it returns the image at clue-th index
   *
   * @returns {object | object[]} all images in an array or the clue-th image
   */
  images() {
    let arr = [];
    this.paragraphs().forEach((p) => {
      arr = arr.concat(p.images());
    });
    return arr
  }

  /**
   * returns all references in the section
   * if an clue is provided then it returns the reference at clue-th index
   *
   * @returns {object | object[]} all references in an array or the clue-th reference
   */
  references() {
    return this._references || []
  }

  //transformations
  /**
   * Removes the section from the document
   *
   * @returns {null|object} the document without this section. or null if there is no document
   */
  remove() {
    if (!this._doc) {
      return null
    }

    let bads = {};
    bads[this.title()] = true;

    //remove children too
    this.children().forEach((sec) => (bads[sec.title()] = true));
    let sections = this._doc.sections();
    sections = sections.filter((sec) => bads.hasOwnProperty(sec.title()) !== true);
    sections = sections.filter((sec) => bads.hasOwnProperty(sec.title()) !== true);

    this._doc._sections = sections;
    return this._doc
  }

  //move-around sections like in jquery
  /**
   * returns the next sibling of this section
   * if it can find one then it returns null
   *
   * @returns {Section|null} the next sibling
   */
  nextSibling() {
    //if this section is not part of a document then we can go to the next part of the document
    if (!this._doc) {
      return null
    }

    //first we get the a list of sections and our own position in this list
    let sections = this._doc.sections();
    let index = this.index() || 0;

    //then we look trough the list looking for the next sibling
    //aka we look the next item at the same depth as us
    //so we start the loop at the next section in the list and go till the length of the list
    for (let i = index + 1; i < sections.length; i++) {
      //if the depth is smaller then the current depth then there is no next sibling
      //aka the depth of the section at position i a level higher then this section then this section is the last section at this depth
      if (sections[i].depth() < this.depth()) {
        return null
      }
      //if the section has the same depth as the current section then it is the next sibling
      if (sections[i].depth() === this.depth()) {
        return sections[i]
      }
    }
    //if the loop has no results then there is no next sibling and we are at the end of the file
    return null
  }

  /**
   * returns the next sibling of this section
   * if it can find one then it returns null
   *
   * @returns {Section|null} the next sibling
   */
  next() {
    return this.nextSibling()
  }

  /**
   * returns the previous section
   *
   * @returns {Section|null} the previous section
   */
  lastSibling() {
    if (!this._doc) {
      return null
    }
    let sections = this._doc.sections();
    let index = this.index() || 0;
    return sections[index - 1] || null
  }

  /**
   * returns the previous section
   *
   * @returns {Section|null} the previous section
   */
  last() {
    return this.lastSibling()
  }

  /**
   * returns the previous section
   *
   * @returns {Section|null} the previous section
   */
  previousSibling() {
    return this.lastSibling()
  }

  /**
   * returns the previous section
   *
   * @returns {Section|null} the previous section
   */
  previous() {
    return this.lastSibling()
  }

  /**
   * returns all the children of a section
   *
   * If the clue is a string then it will return the child with that exact title
   * Else if the clue is a number then it returns the child at that index
   * Else it returns all the children
   *
   * @param {number | string} [clue] A title of a section or a index of a wanted section
   * @returns {Section | Section[] | null} A section or a array of sections
   */
  children(clue) {
    if (!this._doc) {
      return null
    }

    let sections = this._doc.sections();
    let index = this.index() || 0;
    let children = [];

    //(immediately preceding sections with higher depth)
    if (sections[index + 1] && sections[index + 1].depth() > this.depth()) {
      for (let i = index + 1; i < sections.length; i += 1) {
        if (sections[i].depth() > this.depth()) {
          children.push(sections[i]);
        } else {
          break
        }
      }
    }
    if (typeof clue === 'string') {
      return children.find((s) => s.title().toLowerCase() === clue.toLowerCase())
    }
    return children
  }

  /**
   * returns all the children of a section
   *
   * If the clue is a string then it will return the child with that exact title
   * Else if the clue is a number then it returns the child at that index
   * Else it returns all the children
   *
   * @param {number | string} [clue] A title of a section or a index of a wanted section
   * @returns {Section | Section[] | null} A section or a array of sections
   */
  sections(clue) {
    return this.children(clue)
  }

  /**
   * returns all the parent of a section
   *
   * @returns {Section | null} A section that is the parent of a section
   */
  parent() {
    if (!this._doc) {
      return null
    }
    let sections = this._doc.sections();
    let index = this.index() || 0;

    for (let i = index; i >= 0; i -= 1) {
      if (sections[i] && sections[i].depth() < this.depth()) {
        return sections[i]
      }
    }

    return null
  }

  //outputs

  /**
   * returns a plaintext version of the section
   *
   * @param {object} options options for the text transformation
   * @returns {string} the section in text
   */
  text(options) {
    options = setDefaults(options, defaults$2);
    return this.paragraphs()
      .map((p) => p.text(options))
      .join('\n\n')
  }
  /**
   * returns original wiki markup
   *
   * @returns {string} the original markup
   */
  wikitext() {
    return this._wiki
  }

  /**
   * returns a json version of the section
   *
   * @param {object} options keys to include in the resulting json
   * @returns {object} the section in json
   */
  json(options) {
    options = setDefaults(options, defaults$2);
    return toJSON$1(this, options)
  }
}
Section.prototype.citations = Section.prototype.references;

// aliases
const singular$1 = {
  sentences: 'sentence',
  paragraphs: 'paragraph',
  links: 'link',
  tables: 'table',
  templates: 'template',
  infoboxes: 'infobox',
  coordinates: 'coordinate',
  lists: 'list',
  images: 'image',
  references: 'reference',
  citations: 'citation',
};
Object.keys(singular$1).forEach((k) => {
  let sing = singular$1[k];
  Section.prototype[sing] = function (clue) {
    let arr = this[k](clue);
    if (typeof clue === 'number') {
      return arr[clue]
    }
    return arr[0] || null
  };
});

const heading_reg = /^(={1,6})(.{1,200}?)={1,6}$/;
const hasTemplate = /\{\{.+?\}\}/;

const doInlineTemplates = function (wiki, doc) {
  let list = findTemplates(wiki);
  list.forEach((item) => {
    let [txt] = parseTemplate(item, doc);
    wiki = wiki.replace(item.body, txt);
  });
  return wiki
};

/**
 * @typedef fakeSection
 * @property {string} title
 * @property {null | number} depth
 * @property {string} wiki
 */

/**
 * estimates the depth of a section and parses the title to a normal format
 *
 * @private
 * @param {fakeSection} section
 * @param {string} str
 * @param {Document} doc
 * @returns {fakeSection} section the depth in a object
 */
const parseHeading = function (section, str, doc) {
  let m = str.match(heading_reg);
  if (!m) {
    section.title = '';
    section.depth = 0;
    return section
  }
  let title = m[2] || '';
  title = fromText(title).text();

  //amazingly, you can see inline {{templates}} in this text, too
  if (hasTemplate.test(title)) {
    title = doInlineTemplates(title, doc);
  }
  //same for references (i know..)
  let obj = { _wiki: title };
  parseRefs(obj);
  title = obj._wiki;

  //trim leading/trailing whitespace
  title = trim_whitespace(title);
  let depth = 0;
  if (m[1]) {
    depth = m[1].length - 2;
  }
  section.title = title;
  section.depth = depth;
  return section
};

const isReference = new RegExp('^(' + references.join('|') + '):?', 'i');
const section_reg = /(?:\n|^)(={2,6}.{1,200}?={2,6})/g;


/**
 * filters out the reference section and empty sections and
 *
 * @param {Section[]} sections
 * @returns {Section[]} all the section
 */
const removeReferenceSection = function (sections) {
  return sections.filter((s, i) => {
    if (isReference.test(s.title()) === true) {
      if (s.paragraphs().length > 0) {
        return true
      }

      //does it have some wacky templates?
      if (s.templates().length > 0) {
        return true
      }

      //what it has children? awkward
      if (sections[i + 1] && sections[i + 1].depth() > s.depth()) {
        sections[i + 1]._depth -= 1; //move it up a level?...
      }
      return false
    }
    return true
  })
};

/**
 * this function splits the wiki texts on '=' and puts every part in a Section Object
 * it also pre processes the section text for the Section object
 * then it filters out the reference section
 *
 * @private
 * @param {object} doc the document that contains the wiki text
 * @returns {Section[]} the sections that are parsed out
 */
const parseSections = function (doc) {
  let sections = [];
  let splits = doc._wiki.split(section_reg);

  for (let i = 0; i < splits.length; i += 2) {
    let heading = splits[i - 1] || '';
    let wiki = splits[i] || '';

    if (wiki === '' && heading === '') {
      //usually an empty 'intro' section
      continue
    }

    let data = {
      title: '',
      depth: null,
      wiki: wiki,
    };

    //figure-out title and depth
    parseHeading(data, heading, doc);

    sections.push(new Section(data, doc));
  }

  //remove empty references section
  return removeReferenceSection(sections)
};

const cat_reg = new RegExp('\\[\\[(' + _categories.join('|') + '):(.{2,178}?)]](w{0,10})', 'gi');
const cat_remove_reg = new RegExp('^\\[\\[:?(' + _categories.join('|') + '):', 'gi');

const parse_categories = function (wiki) {
  const categories = [];
  let tmp = wiki.match(cat_reg); //regular links
  if (tmp) {
    tmp.forEach(function (c) {
      c = c.replace(cat_remove_reg, '');
      c = c.replace(/\|?[ *]?\]\]$/, ''); //parse fancy ones..
      c = c.replace(/\|.*/, ''); //everything after the '|' is metadata
      if (c && !c.match(/[[\]]/)) {
        categories.push(c.trim());
      }
    });
  }
  const newWiki = wiki.replace(cat_reg, '');
  return [categories, newWiki]
};

const defaults$1 = {
  tables: true,
  lists: true,
  paragraphs: true,
};

/**
 * The document class is the main entry point of wtf_wikipedia.
 * this class represents an article of wikipedia.
 * from here you can go to the infoboxes or paragraphs
 *
 * @class
 */
class Document {
  /**
   * The constructor for the document class
   * This function starts parsing the wiki text and sets the options in the class
   *
   * @param {string} [wiki] The wiki text
   * @param {object} [options] The options for the parser
   */
  constructor(wiki, options) {
    options = options || {};
    this._options = options;
    let userAgent = options.userAgent || options['User-Agent'] || options['Api-User-Agent'];
    userAgent = userAgent || 'User of the wtf_wikipedia library';
    let props = {
      title: options.title || null,
      type: 'page',
      userAgent,
      redirectTo: null,
      wiki: wiki || '',
      categories: [],
      sections: [],
      coordinates: [],
      templateFallbackFn: options.templateFallbackFn || null,
      revisionID: options.revisionID || null,
      timestamp: options.timestamp || null,
      description: options.description || null,
      wikidata: options.wikidata || null,
      pageImage: options.pageImage || null,
      pageID: options.pageID || options.id || null,
      namespace: options.namespace || options.ns || null,
      lang: options.lang || options.language || null,
      domain: options.domain || null,
    };

    Object.keys(props).forEach((k) => {
      Object.defineProperty(this, '_' + k, {
        enumerable: false,
        writable: true,
        value: props[k],
      });
    });

    //detect if page is just redirect, and return it
    if (isRedirect(this._wiki) === true) {
      this._type = 'redirect';
      this._redirectTo = parse(this._wiki);
      const [categories, newWiki] = parse_categories(this._wiki);
      this._categories = categories;
      this._wiki = newWiki;
      return
    }

    //give ourselves a little head-start
    this._wiki = preProcess(this._wiki);

    //pull-out [[category:whatevers]]
    const [categories, newWiki] = parse_categories(this._wiki);
    this._categories = categories;
    this._wiki = newWiki;

    //parse all the headings, and their texts/sentences
    this._sections = parseSections(this);
  }

  /**
   * Getter and setter for the tile.
   * If string is given then this function is a setter and sets the variable and returns the set value
   * If the string is not given then it will check if the title is available
   * If it is available it returns the title.
   * Else it will look if the first sentence contains a bolded phrase and assumes that's the title and returns it
   *
   * @param {string} [str] The title that will be set
   * @returns {null|string} The title found or given
   */
  title(str) {
    //use like a setter
    if (str !== undefined) {
      this._title = str;
      return str
    }
    //if we have it already
    if (this._title) {
      return this._title
    }
    //guess the title of this page from first sentence bolding
    let guess = null;
    let sen = this.sentences()[0];
    if (sen) {
      guess = sen.bold();
    }
    return guess
  }

  /**
   * If an pageID is given then it sets the pageID and returns the given pageID
   * Else if the pageID is already set it returns the pageID
   *
   * @param {number} [id] The pageID that will be set
   * @returns {number|null} The given or found pageID
   */
  pageID(id) {
    if (id !== undefined) {
      this._pageID = id;
    }
    return this._pageID || null
  }

  /**
   * If an WikidataID is given then it sets the WikidataID and returns the given WikidataID
   * Else if the WikidataID is already set it returns the WikidataID
   *
   * @param {string} [id] The WikidataID that will be set
   * @returns {string|null} The given or found WikidataID
   */
  wikidata(id) {
    if (id !== undefined) {
      this._wikidata = id;
    }
    return this._wikidata || null
  }

  /**
   * If an domain is given then it sets the domain and returns the given domain
   * Else if the domain is already set it returns the domain
   *
   * @param {string} [str] The domain that will be set
   * @returns {string|null} The given or found domain
   */
  domain(str) {
    if (str !== undefined) {
      this._domain = str;
    }
    return this._domain || null
  }

  /**
   * If an language is given then it sets the language and returns the given language
   * Else if the language is already set it returns the language
   *
   * @param {string} [lang] The language that will be set
   * @returns {string|null} The given or found language
   */
  language(lang) {
    if (lang !== undefined) {
      this._lang = lang;
    }
    return this._lang || null
  }

  /**
   * Gets the url of the page
   * If the language or domain is not available we substitute 'en' and 'wikipedia.org'
   * Then we use the template of `https://${lang}.${domain}/wiki/${title}` to make the url
   *
   * @returns {string|null} The url of the page
   */
  url() {
    let title = this.title();
    if (!title) {
      return null
    }
    let lang = this.language() || 'en';
    let domain = this.domain() || 'wikipedia.org';
    //replace blank to underscore
    title = title.replace(/ /g, '_');
    title = encodeURIComponent(title);
    return `https://${lang}.${domain}/wiki/${title}`
  }

  /**
   * If an namespace is given then it sets the namespace and returns the given namespace
   * Else if the namespace is already set it returns the namespace
   *
   * @param {string} [ns] The namespace that will be set
   * @returns {string|null} The given or found namespace
   */
  namespace(ns) {
    if (ns !== undefined) {
      this._namespace = ns;
    }
    return this._namespace || null
  }

  /**
   * Returns if the page is a redirect
   *
   * @returns {boolean} Is the page a redirect
   */
  isRedirect() {
    return this._type === 'redirect'
  }
  /**
   * Returns true if the page includes a stub template
   *
   * @returns {boolean} Is the page a stub
   */
  isStub() {
    return isStub(this)
  }

  /**
   * Returns information about the page this page redirects to
   *
   * @returns {null|object} The redirected page
   */
  redirectTo() {
    return this._redirectTo
  }

  /**
   * This function finds out if a page is a disambiguation page
   *
   * @returns {boolean} Whether the page is a disambiguation page
   */
  isDisambiguation() {
    return isDisambig(this)
  }

  /**
   * If a clue is available return the category at that index
   * Else return all categories
   *
   * @returns {string | string[]} The category at the provided index or all categories
   */
  categories(clue) {
    let arr = this._categories || [];
    if (typeof clue === 'number') {
      return [arr[clue]]
    }
    return arr
  }

  /**
   * returns the sections of the document
   *
   * If the clue is a string then it will return the section with that exact title
   * Else if the clue is a number then it returns the section at that index
   * Else it returns all the sections
   *
   * @param {number | string} [clue] A title of a section or a index of a wanted section
   * @returns {object | object[]} A section or a array of sections
   */
  sections(clue) {
    let arr = this._sections || [];
    arr.forEach((sec) => {
      // link-up parent and child
      sec._doc = this;
    });

    //grab a specific section, by its title
    if (typeof clue === 'string') {
      let str = clue.toLowerCase().trim();
      return arr.filter((s) => {
        return s.title().toLowerCase() === str
      })
    } else if (typeof clue === 'number') {
      return [arr[clue]]
    }
    return arr
  }

  /**
   * Returns the paragraphs in the document
   *
   * If the clue is a number then it returns the paragraph at that index
   * Else it returns all paragraphs in an array
   * @param {number | string} [clue] given index of a paragraph
   * @returns {object | object[]} the selected paragraph or an array of all paragraphs
   */
  paragraphs(clue) {
    let arr = [];
    this.sections().forEach((s) => {
      arr = arr.concat(s.paragraphs());
    });
    if (typeof clue === 'number') {
      return [arr[clue]]
    }
    return arr
  }

  /**
   * if no clue is provided, it compiles an array of sentences in the wiki text.
   * if the clue is provided it return the sentence at the provided index
   * @param {number | string} [clue] given index of a sentence
   * @returns {object[]|object} an array of sentences or a single sentence
   */
  sentences(clue) {
    let arr = [];
    this.sections().forEach((sec) => {
      arr = arr.concat(sec.sentences());
    });
    if (typeof clue === 'number') {
      return [arr[clue]]
    }
    return arr
  }

  /**
   * This function search the whole page, including the infobox and image gallery templates for images
   * and then returns them in an array if no clue is provided.
   * if an clue is profieded then it returns the image at the clue-th index
   *
   * @returns {Image[]|Image} a single image or an array of images
   */
  images(clue) {
    let arr = sectionMap(this, 'images', null);
    //grab image from infobox, first
    this.infoboxes().forEach((info) => {
      let img = info.image();
      if (img) {
        arr.unshift(img); //put it at the top
      }
    });
    //look for 'gallery' templates, too
    this.templates().forEach((obj) => {
      if (obj.data.template === 'gallery') {
        obj.data.images = obj.data.images || [];
        obj.data.images.forEach((img) => {
          if (!(img instanceof Image)) {
            img.language = this.language();
            img.domain = this.domain();
            img = new Image(img);
          }
          arr.push(img);
        });
      }
    });
    if (typeof clue === 'number') {
      return [arr[clue]]
    }
    return arr
  }

  /**
   * Return all links or if a clue is provided only the link at that index
   *
   * @param {number} [clue] the index of the wanted link
   * @returns {string[]|string} all the links or the selected link
   */
  links(clue) {
    return sectionMap(this, 'links', clue)
  }

  /**
   * Return all inter wiki links or if a clue is provided only the inter wiki link at that index
   *
   * @param {number} [clue] the index of the wanted inter wiki link
   * @returns {string[]|string} all the inter wiki links or the selected inter wiki link
   */
  interwiki(clue) {
    return sectionMap(this, 'interwiki', clue)
  }

  /**
   * If a clue is available return the list at that index
   * Else return all lists
   *
   * @param {number} [clue] The index of the wanted list
   * @returns {object | object[]} The list at the provided index or all lists
   */
  lists(clue) {
    return sectionMap(this, 'lists', clue)
  }

  /**
   * If a clue is available return the tables at that index
   * Else return all tables
   *
   * @param {number} [clue] The index of the wanted table
   * @returns {object | object[]} The table at the provided index or all tables
   */
  tables(clue) {
    return sectionMap(this, 'tables', clue)
  }

  /**
   * If a clue is available return the template at that index
   * Else return all templates
   *
   * @param {number} [clue] The index of the wanted template
   * @returns {object | object[]} The category at the provided index or all categories
   */
  templates(clue) {
    return sectionMap(this, 'templates', clue)
  }

  /**
   * If a clue is available return the references at that index
   * Else return all references
   *
   * @param {number} [clue] The index of the wanted references
   * @returns {object | object[]} The category at the provided index or all references
   */
  references(clue) {
    return sectionMap(this, 'references', clue)
  }

  /**
   * Returns the 0th or clue-th reference
   *
   * @param {number} [clue] The index of the wanted reference
   * @returns {object|string|number} The reference at the provided index
   */
  citations(clue) {
    return this.references(clue)
  }

  /**
   * finds and returns all coordinates
   * or if an clue is given, the coordinate at the index
   *
   * @param {number} [clue] the index of the coordinate returned
   * @returns {object[]|object|null} if a clue is given, the coordinate of null, else an array of coordinates
   */
  coordinates(clue) {
    return sectionMap(this, 'coordinates', clue)
  }

  /**
   * If clue is unidentified then it returns all infoboxes
   * If clue is a number then it returns the infobox at that index
   * It always sorts the infoboxes by size
   *
   * @param {number} [clue] the index of the infobox you want to select
   * @returns {object | object[]} the selected infobox or an array of infoboxes
   */
  infoboxes(clue) {
    let arr = sectionMap(this, 'infoboxes', clue);
    //sort them by biggest-first
    arr = arr.sort((a, b) => {
      if (Object.keys(a.data).length > Object.keys(b.data).length) {
        return -1
      }
      return 1
    });

    return arr
  }

  /**
   * return a plain text version of the wiki article
   *
   * @param {object} [options] the options for the parser
   * @returns {string} the plain text version of the article
   */
  text(options) {
    options = setDefaults(options, defaults$1);
    //nah, skip these.
    if (this.isRedirect() === true) {
      return ''
    }
    let arr = this.sections().map((sec) => sec.text(options));
    return arr.join('\n\n')
  }

  /**
   * return a json version of the Document class
   *
   * @param {object} [options] options for the rendering
   * @returns {object} this document as json
   */
  json(options) {
    options = setDefaults(options, defaults$1);
    return toJSON$2(this, options)
  }

  /**
   * return original wiki markup
   *
   * @returns {string} markup text
   */
  wikitext() {
    return this._wiki || ''
  }

  /**
   * prints the title of every section
   *
   * @returns {Document} the document itself
   */
  debug() {
    console.log('\n');
    this.sections().forEach((sec) => {
      let indent = ' - ';
      for (let i = 0; i < sec.depth(); i += 1) {
        indent = ' -' + indent;
      }
      console.log(indent + (sec.title() || '(Intro)'));
    });
    return this
  }

  /**
   * If a revisionID is given then it sets the revisionID and returns the given revisionID
   * Else if the revisionID is already set it returns the revisionID
   *
   * @param {number} [id] The revisionID that will be set
   * @returns {number|null} The given or found revisionID
   */
  revisionID(id) {
    if (id !== undefined) {
      this._revisionID = id;
    }
    return this._revisionID || null
  }
  timestamp(str) {
    if (str !== undefined) {
      this._timestamp = str;
    }
    return this._timestamp || null
  }
  description(str) {
    if (str !== undefined) {
      this._description = str;
    }
    return this._description || null
  }
  pageImage(str) {
    if (str !== undefined) {
      this._pageImage = str;
    }
    let file = this._pageImage || null;
    return new Image({ file })
  }

  options() {
    return this._options
  }
}

// aliases
const singular = {
  categories: 'category',
  sections: 'section',
  paragraphs: 'paragraph',
  sentences: 'sentence',
  images: 'image',
  links: 'link',
  // interwiki
  lists: 'list',
  tables: 'table',
  templates: 'template',
  references: 'reference',
  citations: 'citation',
  coordinates: 'coordinate',
  infoboxes: 'infobox',
};
Object.keys(singular).forEach((k) => {
  let sing = singular[k];
  Document.prototype[sing] = function (clue) {
    let arr = this[k](clue);
    return arr[0] || null
  };
});
Document.prototype.lang = Document.prototype.language;
Document.prototype.ns = Document.prototype.namespace;
Document.prototype.plaintext = Document.prototype.text;
Document.prototype.isDisambig = Document.prototype.isDisambiguation;
Document.prototype.citations = Document.prototype.references;
Document.prototype.redirectsTo = Document.prototype.redirectTo;
Document.prototype.redirect = Document.prototype.redirectTo;
Document.prototype.redirects = Document.prototype.redirectTo;

/**
 * this function puts all responses into proper Document objects
 *
 * @private
 * @param {Array} res
 * @param {string | number | Array<number> | Array<string>} title
 * @returns {null| Document | Document[]} null if there are no results or Document if there is one responses and Document array if there are multiple responses
 */
const parseDoc = function (res, title) {
  // filter out undefined
  res = res.filter((o) => o);

  // put all the responses into Document formats
  let docs = res.map((o) => {
    return new Document(o.wiki, o.meta)
  });

  // if the list is empty than there are no results
  if (docs.length === 0) {
    return null
  }

  // if there is only one response then we can get it out of the array
  if (!isArray(title) && docs.length === 1) {
    return docs[0]
  }

  return docs
};

/**
 * factory for header options
 *
 * @private
 * @param {object} options
 * @returns {object} the generated options
 */
const makeHeaders = function (options) {
  let agent =
    options.userAgent || options['User-Agent'] || options['Api-User-Agent'] || 'User of the wtf_wikipedia library';

  let origin;
  if (options.noOrigin) {
    origin = '';
  } else {
    origin = options.origin || options.Origin || '*';
  }

  return {
    method: 'GET',
    headers: {
      'Content-Type': 'application/json',
      'Api-User-Agent': agent,
      'User-Agent': agent,
      Origin: origin,
      'Accept-Encoding': 'gzip',
    },
    redirect: 'follow',
  }
};

const isUrl = /^https?:\/\//;

/**
 * @typedef fetchDefaults
 * @property {string | undefined} [path] the path to the wiki api. default: api.php
 * @property {string | undefined} [wiki]
 * @property {string | undefined} [domain] the domain of the wiki you want to query
 * @property {boolean | undefined} [follow_redirects] should the library follow redirects
 * @property {string | undefined} [lang] the language of the wiki
 * @property {string | number | Array<string> | Array<number> | undefined} [title]
 * @property {string | undefined} [Api-User-Agent] the user agent of the application
 * @property {string | undefined} [origin] the domain or the origin of the request
 */

/**
 * @type {fetchDefaults}
 */
const defaults = {
  lang: 'en',
  wiki: 'wikipedia',
  domain: undefined,
  follow_redirects: true,
  path: 'api.php', //some 3rd party sites use a weird path
};

/**
 * @callback fetchCallback
 * @param {Object} error
 * @param {any} result
 */

/**
 *  fetches the page from the wiki and returns a Promise with the parsed wiki text
 *
 * if you supply it with a single pageID or title it will return a Document object.
 * if you supply a wiki URL then we will parse it and use the tile and provide a single Document object
 * if you supply it with an array with pageIDs or an array of titles it will return an array of document objects.
 *
 * there is another catch in the programming you need if you provide an array it needs to be eighter pageIDs or titles they can not be mixed.
 *
 * @param {string | number | Array<number> | Array<string>} title the title, PageID, URL or an array of all three of the page(s) you want to fetch
 * @param {fetchDefaults} [options] the options for the fetch or the language of the wiki for the article
 * @param {fetchCallback} [callback] the callback function for the call
 */
const fetch = function (title, options, callback) {
  // support lang as 2nd param
  if (typeof options === 'string') {
    options = { lang: options };
  }
  options = { ...defaults, ...options };
  options.title = title;

  //parse url input
  if (typeof title === 'string' && isUrl.test(title)) {
    options = { ...options, ...parseUrl(title) };
  }
  const url = makeUrl(options);
  const headers = makeHeaders(options);

  return unfetch(url, headers)
    .then((res) => res.json())
    .then((res) => {
      if (!res) {
        throw new Error(`No JSON Data Found For ${url}`)
      }
      let data = getResult(res, options);
      data = parseDoc(data, title);
      if (callback) {
        callback(null, data);
      }
      return data
    })
    .catch((e) => {
      console.error(e);
      if (callback) {
        callback(e, null);
      }
      return null
    })
};

var version = '10.3.2';

/**
 * use the native client-side fetch function
 *
 * @private
 * @param {string} url the url that well be fetched
 * @param {Object} opts the options for fetch
 * @returns {Promise<any>} the response from fetch
 */
const request = function (url, opts) {
  return unfetch(url, opts).then(function (res) {
    return res.json()
  }).catch((e) => {
    console.error('\n\n=-=- http response error =-=-=-');
    console.error(url);
    console.error(e);
    return {}
  })
};

//the main 'factory' exported method
const wtf = function (wiki, options) {
  return new Document(wiki, options)
};

const models = {
  Doc: Document,
  Section,
  Paragraph,
  Sentence,
  Image,
  Infobox,
  Link,
  List,
  Reference,
  Table,
  Template,
  http: request,
  wtf: wtf,
};

wtf.fetch = function (title, options, cb) {
  return fetch(title, options, cb)
};
wtf.extend = function (fn) {
  fn(models, templates, infoboxes);
  return this
};
wtf.plugin = wtf.extend;
wtf.version = version;

export { wtf as default };