Module:Annotated link

 localfunctionpipedLink(name,display)return'[[:'..name..'|'..display..']]'end

 localfunctionisEmpty(value)returnvalue==nilorvalue==''end

 localfunctionnotEmpty(value)returnnotisEmpty(value)end

 -- Unescape functionality grabbed from https://stackoverflow.com/a/14899740/1832568
 localfunctionunescape(str)
 str=string.gsub(str,'&#(%d+);',string.char)
 str=string.gsub(str,'&#x(%d+);',function(d)returnstring.char(tonumber(d,16))end)
 returnstr
 end

 localfunctionhashDelimitedList(list_string)returnmw.text.gsplit(unescape(list_string),'%s*#%s*')end

 localfunctionalarmingMessage(message)
 return'<span style="color:#d33">[[Module:Annotated link]] '..message..'.</span>'..
 '[[Category:Pages displaying alarming messages about Module:Annotated link]]'
 end

 localfunctionoptionallyVisibleCategory(class,category)
 return'<span style="display:none" class="'..class..'">'..category..
 '</span>[[Category:'..category..' via Module:Annotated link]]'
 end

 localfunctionhandleFirstLetterCase(short_description,case)
 returnmw.ustring.gsub(short_description,'^([^%d])',function(first_char)
 ifcase=='upper'then
 returnmw.ustring.upper(first_char)
 end
 returnmw.ustring.lower(first_char)end
 )
 end

 localmLang=require('Module:Lang')
 localfunctionlangify(args)
 locallang=args.lang
 localtext=args.text
 ifisEmpty(lang)orlang=='en'then
 returntext
 end
 returnmLang._lang{
 lang,
 text,
 italic=args.italic,
 nocat=args.nocat,
 size=args.size,
 cat=args.cat,
 rtl=args.rtl
 }
 end

 localfunctionformatResult(result,dash,description,prefix_parentheses)
 ifnotEmpty(description)then
 ifprefix_parenthesesthen
 localstartIdx=description:find("%(")
 ifstartIdxthen
 localbeforeParens=description:sub(1,startIdx-2)
 localinsideParens=description:sub(startIdx,-1)
 returnresult..' '..insideParens..dash..' '..beforeParens
 end
 end
 returnresult..dash..' '..description
 end
 returnresult
 end

 localfunctionannotatedLink(args)
 localname=args.name
 ifisEmpty(name)then
 returnalarmingMessage('requires a page name (including namespace)')
 end

 -- In order to handle an attempt to annotate a template link
 -- already formatted with the likes of {{tl|<template name>}};
 -- unescape name to make sense of braces in lua patern matching.
 name=unescape(name)

 ifname:match('^{%b{}}$')then
 -- The possibility to extract useful data exists here: e.g. {{tl*|Template}}.
 returnalarmingMessage(
 'requires only a page name (including namespace) without markup. '..
 'If an attempt is being made to annotate a link to a template, '..
 'provide only the template name with namespace e.g. "Template:Example"')
 end

 -- If a literal link was provided as name;
 -- extract the content and apply it to name and display as appropriate.
 localwikilink=mw.ustring.match(name,'^%[%[%s*:*%s*(.-)%s*%]%]$')
 ifwikilinkthen
 locallink_name,link_display=unpack(mw.text.split(wikilink,'%s*|%s*'))
 iflink_namethen
 name=link_name
 end
 iflink_displayandisEmpty(args.display)then
 args.display=link_display
 end
 end

 -- Prepare to concatenate.
 localresult

 localis_template=name:match('^Template:(.+)$')
 localtemplate_link=args.template_link
 ifis_templateandtemplate_link~='no'then
 result='{{'..pipedLink(name,is_template)..'}}'
 iftemplate_link=='code'then
 result='<code>'..result..'</code>'
 end
 else
 localdisplay=args.display
 ifisEmpty(display)then
 display=name
 end
 result=langify({
 lang=args.link_lang,
 text=pipedLink(name,display),
 italic=args.link_lang_italic,
 nocat=args.link_lang_nocat,
 size=args.link_lang_size,
 cat=args.link_lang_cat,
 rtl=args.link_lang_rtl
 })

 ifnotEmpty(args.quote)then
 result='"'..result..'"'
 end

 localabbr=args.abbr
 ifnotEmpty(abbr)then
 result=result..' (<abbr'
 localabbr_title=args.abbr_title
 ifnotEmpty(abbr_title)then
 result=result..' title="'..abbr_title..'"'
 end
 result=result..'>'..abbr..'</abbr>)'
 end
 end

 ifisEmpty(result)then
 returnalarmingMessage('could not create a link for "'..name..'"')
 end

 localaka=args.aka
 ifnotEmpty(aka)then
 result=result..', also known as '..langify({
 lang=args.aka_lang,
 text=aka,
 italic=args.aka_lang_italic,
 nocat=args.aka_lang_nocat,
 size=args.aka_lang_size,
 cat=args.aka_lang_cat,
 rtl=args.aka_lang_rtl
 })
 end

 localwedge=args.wedge
 ifnotEmpty(wedge)then
 result=result..', '..langify({
 lang=args.wedge_lang,
 text=wedge,
 italic=args.wedge_lang_italic,
 nocat=args.wedge_lang_nocat,
 size=args.wedge_lang_size,
 cat=args.wedge_lang_cat,
 rtl=args.wedge_lang_rtl
 })
 end

 -- Exclude wikidata fallback for any specified list of link titles,
 -- unless explicity instructed that it's okay.
 localnot_wikidata_for_links_starting_with=args.not_wikidata_for_links_starting_with
 ifisEmpty(args.wikidata)andnotEmpty(not_wikidata_for_links_starting_with)then
 foronly_explicitinhashDelimitedList(not_wikidata_for_links_starting_with)do
 ifname:match('^'..only_explicit)then
 args.only='explicit'
 break
 end
 end
 end

 -- Get the short description from Module:GetShortDescription.
 localshort_description=require('Module:GetShortDescription').main({
 none_is_valid=args.none_is_valid,
 none_is_nil=args.none_is_nil,
 lang_italic=args.desc_lang_italic,
 lang_nocat=args.desc_lang_nocat,
 lang_size=args.desc_lang_size,
 lang_cat=args.desc_lang_cat,
 lang_rtl=args.desc_lang_rtl,
 lang_no=args.desc_lang_no,
 prefer=args.prefer,
 only=args.only,
 name=name
 })

 localdash=args.dash
 ifisEmpty(dash)then
 dash='&nbsp;–'
 end

 localfallback=args.fallback

 ifisEmpty(short_description)orshort_description.redlinkthen
 returnformatResult(result,dash,fallback,args.prefix_parentheses)
 end

 ifshort_description.alarmthen
 returnshort_description.alarm
 end

 localmaintenance=''

 ifshort_description.redirectedthen
 maintenance=optionallyVisibleCategory(
 'category-annotation-with-redirected-description',
 'Pages displaying short descriptions of redirect targets')
 end

 localfellback

 ifshort_description.wikidatathen
 --	if short_description.fellback then
 --		fellback = true
 --		maintenance = maintenance..optionallyVisibleCategory(
 --			'category-wikidata-fallback-annotation',
 --			'Pages displaying wikidata descriptions as a fallback')
 --	end
 --	short_description = short_description.wikidata
 -- Filter against likely rubbish wikidata descriptions.
 --	local not_wikidata_descriptions_including = args.not_wikidata_descriptions_including
 --	if notEmpty(not_wikidata_descriptions_including) then
 -- Case insentive matching.
 --		local lower_case_short_description = short_description:lower()
 --		for exclusion in hashDelimitedList(not_wikidata_descriptions_including:lower()) do
 --			if lower_case_short_description:match(exclusion) then
 short_description=''
 --				break
 --			end
 --		end
 --	end
 ifisEmpty(short_description)then
 returnformatResult(result,dash,fallback,args.prefix_parentheses)
 end
 else
 short_description=short_description.explicit
 end

 locallower_case_name=name:lower()

 ifnotEmpty(short_description)andnotshort_description:match(' ')then
 -- Filter against likely rubbish single word descriptions.
 locallower_case_short_description=short_description:lower()
 localnot_single_word=args.not_single_word
 ifnotEmpty(not_single_word)then
 -- Case insentive matching.
 forsingle_wordinhashDelimitedList(not_single_word:lower())do
 ifsingle_word==lower_case_short_descriptionthen
 short_description=''
 break
 end
 end
 end
 ifisEmpty(short_description)orlower_case_name:match(lower_case_short_description)then
 returnformatResult(result,dash,fallback,args.prefix_parentheses)
 end
 ifisEmpty(args.space_cat)then
 maintenance=maintenance..optionallyVisibleCategory(
 'category-spaceless-annotation',
 'Pages displaying short descriptions with no spaces')
 end
 end

 iflower_case_name==short_description:lower()then
 iffellbackthen
 returnformatResult(result,dash,fallback,args.prefix_parentheses)
 end
 maintenance=maintenance..optionallyVisibleCategory(
 'category-annotation-matches-name',
 'Pages displaying short descriptions matching their page name')
 end

 -- Short descriptions on en Wikipedia should be formatted with an uppercase first letter, but
 -- the typical application of this module will require the first character to be lowercase, but
 -- some descriptions may start with proper names and should start with an uppercase letter even if used in an annotaion.
 -- By default; this module will not affect the first letter case of descriptions retrieved by Module:GetShortDescription, but
 -- the first letter case may be transformed explicitly if required.
 localdesc_first_letter_case=args.desc_first_letter_case
 ifdesc_first_letter_case=='upper'ordesc_first_letter_case=='lower'then
 short_description=handleFirstLetterCase(short_description,desc_first_letter_case)
 end

 returnformatResult(result,dash,(short_descriptionorfallback)..maintenance,args.prefix_parentheses)
 end

 localp={}

 functionp.main(frame)
 localargs=require('Module:Arguments').getArgs(frame)
 ifisEmpty(args)then
 returnalarmingMessage('could not getArgs')-- This really would be alarming.
 end
 returnannotatedLink(args)
 end

 returnp