https://www.droz.org/store/js/CSL.js?clientCacheVersion=20250927112400

1if (!Array.indexOf) {
2	Array.prototype.indexOf = function (obj) {
3		var i, len;
4		for (i = 0, len = this.length; i < len; i += 1) {
5			if (this[i] === obj) {
6				return i;
7			}
8		}
9		return -1;
10	};
11}
12if ("undefined" === typeof CSL_IS_IE) {
13    var CSL_IS_IE;
14};
15var CSL_CHROME = function () {
16    if ("undefined" == typeof DOMParser || CSL_IS_IE) {
17        CSL_IS_IE = true;
18        DOMParser = function() {};
19        DOMParser.prototype.parseFromString = function(str, contentType) {
20            if ("undefined" != typeof ActiveXObject) {
21                var xmldata = new ActiveXObject('MSXML.DomDocument');
22                xmldata.async = false;
23                xmldata.loadXML(str);
24                return xmldata;
25            } else if ("undefined" != typeof XMLHttpRequest) {
26                var xmldata = new XMLHttpRequest;
27                if (!contentType) {
28                    contentType = 'text/xml';
29                }
30                xmldata.open('GET', 'data:' + contentType + ';charset=utf-8,' + encodeURIComponent(str), false);
31                if(xmldata.overrideMimeType) {
32                    xmldata.overrideMimeType(contentType);
33                }
34                xmldata.send(null);
35                return xmldata.responseXML;
36            }
37        };
38        this.hasAttributes = function (node) {
39            var ret;
40            if (node.attributes && node.attributes.length) {
41                ret = true;
42            } else {
43                ret = false;

44            }
45            return ret;
46        };
47    } else {
48        this.hasAttributes = function (node) {
49            var ret;
50            if (node.attributes && node.attributes.length) {
51                ret = true;
52            } else {
53                ret = false;
54            }
55            return ret;
56        };
57    }
58    this.importNode = function (doc, srcElement) {
59        if ("undefined" == typeof doc.importNode) {
60            var ret = this._importNode(doc, srcElement, true);
61        } else {
62            var ret = doc.importNode(srcElement, true);
63        }
64        return ret;
65    };
66    this._importNode = function(doc, node, allChildren) {
67        switch (node.nodeType) {
68            case 1:
69                var newNode = doc.createElement(node.nodeName);
70                if (node.attributes && node.attributes.length > 0)
71                    for (var i = 0, il = node.attributes.length; i < il;)
72                        newNode.setAttribute(node.attributes[i].nodeName, node.getAttribute(node.attributes[i++].nodeName));
73                    if (allChildren && node.childNodes && node.childNodes.length > 0)
74                        for (var i = 0, il = node.childNodes.length; i < il;)
75                            newNode.appendChild(this._importNode(doc, node.childNodes[i++], allChildren));
76                return newNode;
77                break;
78            case 3:
79            case 4:
80            case 8:
81        }
82    };
83    this.parser = new DOMParser();
84    var str = "<docco><institution institution-parts=\"long\" delimiter=\", \" substitute-use-first=\"1\" use-last=\"1\"><institution-part name=\"long\"/></institution></docco>";
85    var inst_doc = this.parser.parseFromString(str, "text/xml");
86    var inst_node = inst_doc.getElementsByTagName("institution");
87    this.institution = inst_node.item(0);
88    var inst_part_node = inst_doc.getElementsByTagName("institution-part");
89    this.institutionpart = inst_part_node.item(0);
90    this.ns = "http://purl.org/net/xbiblio/csl";
91};
92CSL_CHROME.prototype.clean = function (xml) {
93    xml = xml.replace(/<\?[^?]+\?>/g, "");
94    xml = xml.replace(/<![^>]+>/g, "");
95    xml = xml.replace(/^\s+/, "");
96    xml = xml.replace(/\s+$/, "");
97    xml = xml.replace(/^\n*/, "");
98    return xml;
99};
100CSL_CHROME.prototype.getStyleId = function (myxml) {
101    var text = "";
102    var node = myxml.getElementsByTagName("id");
103    if (node && node.length) {
104        node = node.item(0);
105    }
106    if (node) {
107        text = node.textContent;
108    }
109    if (!text) {
110        text = node.innerText;
111    }
112    if (!text) {
113        text = node.innerHTML;
114    }
115    return text;
116};
117CSL_CHROME.prototype.children = function (myxml) {
118    var children, pos, len, ret;
119    if (myxml) {
120        ret = [];
121        children = myxml.childNodes;
122        for (pos = 0, len = children.length; pos < len; pos += 1) {
123            if (children[pos].nodeName != "#text") {
124                ret.push(children[pos]);
125            }
126        }
127        return ret;
128    } else {
129        return [];
130    }
131};
132CSL_CHROME.prototype.nodename = function (myxml) {
133    var ret = myxml.nodeName;
134    return ret;
135};
136CSL_CHROME.prototype.attributes = function (myxml) {
137    var ret, attrs, attr, key, xml, pos, len;
138    ret = new Object();
139    if (myxml && this.hasAttributes(myxml)) {
140        attrs = myxml.attributes;
141        for (pos = 0, len=attrs.length; pos < len; pos += 1) {
142            attr = attrs[pos];
143            ret["@" + attr.name] = attr.value;
144        }
145    }
146    return ret;
147};
148CSL_CHROME.prototype.content = function (myxml) {
149    var ret;
150    if ("undefined" != typeof myxml.textContent) {
151        ret = myxml.textContent;
152    } else if ("undefined" != typeof myxml.innerText) {
153        ret = myxml.innerText;
154    } else {
155        ret = myxml.txt;
156    }
157    return ret;
158};
159CSL_CHROME.prototype.namespace = {
160    "xml":"http://www.w3.org/XML/1998/namespace"
161}
162CSL_CHROME.prototype.numberofnodes = function (myxml) {
163    if (myxml) {
164        return myxml.length;
165    } else {
166        return 0;
167    }
168};
169CSL_CHROME.prototype.getAttributeName = function (attr) {
170    var ret = attr.name;
171    return ret;
172}
173CSL_CHROME.prototype.getAttributeValue = function (myxml,name,namespace) {
174    var ret = false;

175    if (namespace) {
176        name = namespace+":"+name;
177    }
178    if (myxml && this.hasAttributes(myxml)) {
179        if (myxml.getAttribute(name)) {
180            ret = myxml.getAttribute(name);
181        }
182    } else {
183        ret = "";
184    }
185    return ret;
186}
187CSL_CHROME.prototype.getNodeValue = function (myxml,name) {
188    var ret = "";
189    if (name){
190        var vals = myxml.getElementsByTagName(name);
191        if (vals.length > 0) {
192            if ("undefined" != typeof vals[0].textContent) {
193                ret = vals[0].textContent;
194            } else if ("undefined" != typeof vals[0].innerText) {
195                ret = vals[0].innerText;
196            } else {
197                ret = vals[0].text;
198            }
199        }
200    } else {
201        ret = myxml;
202    }
203    if (ret && ret.childNodes && (ret.childNodes.length == 0 || (ret.childNodes.length == 1 && ret.firstChild.nodeName == "#text"))) {
204        if ("undefined" != typeof ret.textContent) {
205            ret = ret.textContent;
206        } else if ("undefined" != typeof ret.innerText) {
207            ret = ret.innerText;
208        } else {
209            ret = ret.text;
210        }
211    }
212    return ret;
213}
214CSL_CHROME.prototype.setAttributeOnNodeIdentifiedByNameAttribute = function (myxml,nodename,partname,attrname,val) {
215    var pos, len, xml, nodes, node;
216    if (attrname.slice(0,1) === '@'){
217        attrname = attrname.slice(1);
218    }
219    nodes = myxml.getElementsByTagName(nodename);
220    for (pos = 0, len = nodes.length; pos < len; pos += 1) {
221        node = nodes[pos];
222        if (node.getAttribute("name") != partname) {
223            continue;
224        }
225        node.setAttribute(attrname, val);
226    }
227}
228CSL_CHROME.prototype.deleteNodeByNameAttribute = function (myxml,val) {
229    var pos, len, node, nodes;
230    nodes = myxml.childNodes;
231    for (pos = 0, len = nodes.length; pos < len; pos += 1) {
232        node = nodes[pos];
233        if (!node || node.nodeType == node.TEXT_NODE) {
234            continue;
235        }
236        if (this.hasAttributes(node) && node.getAttribute("name") == val) {
237            myxml.removeChild(nodes[pos]);
238        }
239    }
240}
241CSL_CHROME.prototype.deleteAttribute = function (myxml,attr) {
242    myxml.removeAttribute(attr);
243}
244CSL_CHROME.prototype.setAttribute = function (myxml,attr,val) {
245    if (!myxml.ownerDocument) {
246        myxml = myxml.firstChild;
247    }
248    if (["function", "unknown"].indexOf(typeof myxml.setAttribute) > -1) {
249        myxml.setAttribute(attr, val);
250    }
251    return false;
252}
253CSL_CHROME.prototype.nodeCopy = function (myxml) {
254    var cloned_node = myxml.cloneNode(true);
255    return cloned_node;
256}
257CSL_CHROME.prototype.getNodesByName = function (myxml,name,nameattrval) {
258    var ret, nodes, node, pos, len;
259    ret = [];
260    nodes = myxml.getElementsByTagName(name);
261    for (pos = 0, len = nodes.length; pos < len; pos += 1) {
262        node = nodes.item(pos);
263        if (nameattrval && !(this.hasAttributes(node) && node.getAttribute("name") == nameattrval)) {
264            continue;
265        }
266        ret.push(node);
267    }
268    return ret;
269}
270CSL_CHROME.prototype.nodeNameIs = function (myxml,name) {
271    if (name == myxml.nodeName) {
272        return true;
273    }
274    return false;
275}
276CSL_CHROME.prototype.makeXml = function (myxml) {
277    var ret, topnode;
278    if (!myxml) {
279        myxml = "<docco><bogus/></docco>";
280    }
281    myxml = myxml.replace(/\s*<\?[^>]*\?>\s*\n*/g, "");
282    var nodetree = this.parser.parseFromString(myxml, "application/xml");
283    return nodetree.firstChild;
284};
285CSL_CHROME.prototype.insertChildNodeAfter = function (parent,node,pos,datexml) {
286    var myxml, xml;
287    myxml = this.importNode(node.ownerDocument, datexml);
288    parent.replaceChild(myxml, node);
289     return parent;
290};
291CSL_CHROME.prototype.insertPublisherAndPlace = function(myxml) {
292    var group = myxml.getElementsByTagName("group");
293    for (var i = 0, ilen = group.length; i < ilen; i += 1) {
294        var node = group.item(i);
295        var skippers = [];
296        for (var j = 0, jlen = node.childNodes.length; j < jlen; j += 1) {
297            if (node.childNodes.item(j).nodeType !== 1) {
298                skippers.push(j);
299            }
300        }
301        if (node.childNodes.length - skippers.length === 2) {
302            var twovars = [];
303            for (var j = 0, jlen = 2; j < jlen; j += 1) {
304                if (skippers.indexOf(j) > -1) {
305                    continue;
306                }
307                var child = node.childNodes.item(j);                    
308                var subskippers = [];
309                for (var k = 0, klen = child.childNodes.length; k < klen; k += 1) {
310                    if (child.childNodes.item(k).nodeType !== 1) {
311                        subskippers.push(k);
312                    }
313                }
314                if (child.childNodes.length - subskippers.length === 0) {
315                    twovars.push(child.getAttribute('variable'));
316                    if (child.getAttribute('suffix')
317                        || child.getAttribute('prefix')) {
318                        twovars = [];
319                        break;
320                    }
321                }
322            }
323            if (twovars.indexOf("publisher") > -1 && twovars.indexOf("publisher-place") > -1) {
324                node.setAttribute('has-publisher-and-publisher-place', true);
325            }
326        }
327    }
328};
329CSL_CHROME.prototype.addMissingNameNodes = function(myxml) {
330    var nameslist = myxml.getElementsByTagName("names");
331    for (var i = 0, ilen = nameslist.length; i < ilen; i += 1) {
332        var names = nameslist.item(i);
333        var namelist = names.getElementsByTagName("name");
334        if ((!namelist || namelist.length === 0)
335            && names.parentNode.tagName.toLowerCase() !== "substitute") {
336            var doc = names.ownerDocument;
337            var name = doc.createElement("name");
338            names.appendChild(name);
339        }
340    }
341};
342CSL_CHROME.prototype.addInstitutionNodes = function(myxml) {
343    var names, thenames, institution, theinstitution, name, thename, xml, pos, len;
344    names = myxml.getElementsByTagName("names");
345    for (pos = 0, len = names.length; pos < len; pos += 1) {
346        thenames = names.item(pos);
347        name = thenames.getElementsByTagName("name");
348        if (name.length == 0) {
349            continue;
350        }
351        institution = thenames.getElementsByTagName("institution");
352        if (institution.length == 0) {
353            theinstitution = this.importNode(myxml.ownerDocument, this.institution);
354            theinstitutionpart = theinstitution.getElementsByTagName("institution-part").item(0);
355            thename = name.item(0);
356            thenames.insertBefore(theinstitution, thename.nextSibling);

357            for (var j = 0, jlen = CSL.INSTITUTION_KEYS.length; j < jlen; j += 1) {
358                var attrname = CSL.INSTITUTION_KEYS[j];
359                var attrval = thename.getAttribute(attrname);
360                if (attrval) {
361                    theinstitutionpart.setAttribute(attrname, attrval);
362                }
363            }
364            var nameparts = thename.getElementsByTagName("name-part");
365            for (var j = 0, jlen = nameparts.length; j < jlen; j += 1) {
366                if ('family' === nameparts[j].getAttribute('name')) {
367                    for (var k = 0, klen = CSL.INSTITUTION_KEYS.length; k < klen; k += 1) {
368                        var attrname = CSL.INSTITUTION_KEYS[k];
369                        var attrval = nameparts[j].getAttribute(attrname);
370                        if (attrval) {
371                            theinstitutionpart.setAttribute(attrname, attrval);
372                        }
373                    }
374                }
375            }
376        }
377    }
378};
379CSL_CHROME.prototype.flagDateMacros = function(myxml) {
380    var pos, len, thenode, thedate;
381    nodes = myxml.getElementsByTagName("macro");
382    for (pos = 0, len = nodes.length; pos < len; pos += 1) {
383        thenode = nodes.item(pos);
384        thedate = thenode.getElementsByTagName("date");
385        if (thedate.length) {
386            thenode.setAttribute('macro-has-date', 'true');
387        }
388    }
389};
390var CSL = {
391	PROCESSOR_VERSION: "1.0.550",
392	CONDITION_LEVEL_TOP: 1,
393	CONDITION_LEVEL_BOTTOM: 2,
394	PLAIN_HYPHEN_REGEX: /(?:[^\\]-|\u2013)/,
395	LOCATOR_LABELS_REGEXP: new RegExp("^((art|ch|Ch|subch|col|fig|l|n|no|op|p|pp|para|subpara|pt|r|sec|subsec|Sec|sv|sch|tit|vrs|vol)\\.)\\s+(.*)"),
396	STATUTE_SUBDIV_GROUPED_REGEX: /((?:^| )(?:art|ch|Ch|subch|p|pp|para|subpara|pt|r|sec|subsec|Sec|sch|tit)\.)/g,
397	STATUTE_SUBDIV_PLAIN_REGEX: /(?:(?:^| )(?:art|ch|Ch|subch|p|pp|para|subpara|pt|r|sec|subsec|Sec|sch|tit)\.)/,
398	STATUTE_SUBDIV_STRINGS: {
399		"art.": "article",
400		"bk.": "book",
401		"ch.": "chapter",
402		"Ch.": "Chapter",
403		"subch.": "subchapter",
404		"p.": "page",
405		"pp.": "page",
406		"para.": "paragraph",
407		"subpara.": "subparagraph",
408		"pt.": "part",
409		"r.": "rule",
410		"sec.": "section",
411		"subsec.": "subsection",
412		"Sec.": "Section",
413		"sch.": "schedule",
414		"tit.": "title",
415		"col.": "column",
416		"fig.": "figure",
417		"fol.": "folio",
418		"l.": "line",
419		"n.": "note",
420		"no.": "issue",
421		"op.": "opus",
422		"sv.": "sub-verbo",
423		"vrs.": "verse",
424		"vol.": "volume"
425	},
426	STATUTE_SUBDIV_STRINGS_REVERSE: {
427		"article": "art.",
428		"book": "bk.",
429		"chapter": "ch.",
430		"Chapter": "Ch.",
431		"subchapter": "subch.",
432		"page": "p.",
433		"paragraph": "para.",
434		"subparagraph": "subpara.",
435		"part": "pt.",
436		"rule": "r.",
437		"section": "sec.",
438		"subsection": "subsec.",
439		"Section": "Sec.",
440		"schedule": "sch.",
441		"title": "tit.",
442		"column": "col.",
443		"figure": "fig.",
444		"folio": "fol.",
445		"line": "l.",
446		"note": "n.",
447		"issue": "no.",
448		"opus": "op.",
449		"sub-verbo": "sv.",
450		"sub verbo": "sv.",
451		"verse": "vrs.",
452		"volume": "vol."
453	},
454	LOCATOR_LABELS_MAP: {
455		"art": "article",
456		"bk": "book",
457		"ch": "chapter",
458		"Ch": "Chapter",
459		"subch": "subchapter",
460		"col": "column",
461		"fig": "figure",
462		"fol": "folio",
463		"l": "line",
464		"n": "note",
465		"no": "issue",
466		"op": "opus",
467		"p": "page",
468		"pp": "page",
469		"para": "paragraph",
470		"subpara": "subparagraph",
471		"pt": "part",
472		"r": "rule",
473		"sec": "section",
474		"subsec": "subsection",
475		"Sec": "Section",
476		"sv": "sub-verbo",
477		"sch": "schedule",
478		"tit": "title",
479		"vrs": "verse",
480		"vol": "volume"
481	},
482	NestedBraces: [
483		["(", "["],
484		[")", "]"]
485	],
486	checkNestedBraceOpen: new RegExp(".*\\("),
487	checkNestedBraceClose: new RegExp(".*\\)"),
488	LangPrefsMap: {
489		"title":"titles",
490		"title-short":"titles",
491		"container-title":"journals",
492		"collection-title":"journals",
493		"publisher":"publishers",
494		"authority":"publishers",
495		"publisher-place": "places",
496		"event-place": "places",
497		"number": "number",
498		"edition":"number",
499		"issue":"number",
500		"volume":"number"
501	},
502	AbbreviationSegments: function () {
503		this["container-title"] = {};
504		this["collection-title"] = {};
505		this["institution-entire"] = {};
506		this["institution-part"] = {};
507		this.nickname = {};
508		this.number = {};
509		this.title = {};
510		this.place = {};
511		this.hereinafter = {};
512		this.classic = {};
513		this["container-phrase"] = {};
514		this["title-phrase"] = {};
515	},
516	GENDERS: ["masculine", "feminine"],
517	ERROR_NO_RENDERED_FORM: 1,
518	PREVIEW: "Just for laughs.",

519	ASSUME_ALL_ITEMS_REGISTERED: 2,
520	START: 0,
521	END: 1,
522	SINGLETON: 2,
523	SEEN: 6,
524	SUCCESSOR: 3,
525	SUCCESSOR_OF_SUCCESSOR: 4,
526	SUPPRESS: 5,
527	SINGULAR: 0,
528	PLURAL: 1,
529	LITERAL: true,
530	BEFORE: 1,
531	AFTER: 2,
532	DESCENDING: 1,
533	ASCENDING: 2,
534	ONLY_FIRST: 1,
535	ALWAYS: 2,
536	ONLY_LAST: 3,
537	FINISH: 1,
538	POSITION_FIRST: 0,
539	POSITION_SUBSEQUENT: 1,
540	POSITION_IBID: 2,
541	POSITION_IBID_WITH_LOCATOR: 3,
542	MARK_TRAILING_NAMES: true,
543	POSITION_TEST_VARS: ["position", "first-reference-note-number", "near-note"],
544	AREAS: ["citation", "citation_sort", "bibliography", "bibliography_sort"],
545	MULTI_FIELDS: ["event", "publisher", "publisher-place", "event-place", "title", "container-title", "collection-title", "authority","edition","genre","title-short","medium","jurisdiction","archive","archive-place"],
546	CITE_FIELDS: ["first-reference-note-number", "locator", "locator-revision"],
547	MINIMAL_NAME_FIELDS: ["literal", "family"],
548	SWAPPING_PUNCTUATION: [".", "!", "?", ":", ","],
549	TERMINAL_PUNCTUATION: [":", ".", ";", "!", "?", " "],
550	NONE: 0,
551	NUMERIC: 1,
552	POSITION: 2,
553	COLLAPSE_VALUES: ["citation-number", "year", "year-suffix"],
554	DATE_PARTS: ["year", "month", "day"],
555	DATE_PARTS_ALL: ["year", "month", "day", "season"],
556	DATE_PARTS_INTERNAL: ["year", "month", "day", "year_end", "month_end", "day_end"],
557	NAME_PARTS: ["family", "given", "dropping-particle", "non-dropping-particle", "suffix", "literal"],
558	DECORABLE_NAME_PARTS: ["given", "family", "suffix"],
559	DISAMBIGUATE_OPTIONS: [
560		"disambiguate-add-names",
561		"disambiguate-add-givenname",
562		"disambiguate-add-year-suffix"
563	],
564	GIVENNAME_DISAMBIGUATION_RULES: [
565		"all-names",
566		"all-names-with-initials",
567		"primary-name",
568		"primary-name-with-initials",
569		"by-cite"
570	],
571	NAME_ATTRIBUTES: [
572		"and",
573		"delimiter-precedes-last",
574		"delimiter-precedes-et-al",
575		"initialize-with",
576		"initialize",
577		"name-as-sort-order",
578		"sort-separator",
579		"et-al-min",
580		"et-al-use-first",
581		"et-al-subsequent-min",
582		"et-al-subsequent-use-first",
583		"form",
584		"prefix",
585		"suffix",
586		"delimiter"
587	],
588	PARALLEL_MATCH_VARS: ["container-title"],
589	PARALLEL_TYPES: ["bill","gazette","regulation","legislation","legal_case","treaty","article-magazine","article-journal"],
590	PARALLEL_COLLAPSING_MID_VARSET: ["volume", "issue", "container-title", "section", "collection-number"],
591	LOOSE: 0,
592	STRICT: 1,
593	TOLERANT: 2,
594	PREFIX_PUNCTUATION: /[.;:]\s*$/,
595	SUFFIX_PUNCTUATION: /^\s*[.;:,\(\)]/,
596	NUMBER_REGEXP: /(?:^\d+|\d+$)/,
597	NAME_INITIAL_REGEXP: /^([A-Z\u0590-\u05ff\u0080-\u017f\u0400-\u042f\u0600-\u06ff\u0370\u0372\u0376\u0386\u0388-\u03ab\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f7\u03fd-\u03ff])([a-zA-Z\u0080-\u017f\u0400-\u052f\u0600-\u06ff\u0370-\u03ff\u1f00-\u1fff]*|)/,
598	ROMANESQUE_REGEXP: /[-0-9a-zA-Z\u0590-\u05d4\u05d6-\u05ff\u0080-\u017f\u0400-\u052f\u0370-\u03ff\u1f00-\u1fff\u0600-\u06ff\u200c\u200d\u200e\u0218\u0219\u021a\u021b\u202a-\u202e]/,
599	ROMANESQUE_NOT_REGEXP: /[^a-zA-Z\u0590-\u05ff\u0080-\u017f\u0400-\u052f\u0370-\u03ff\u1f00-\u1fff\u0600-\u06ff\u200c\u200d\u200e\u0218\u0219\u021a\u021b\u202a-\u202e]/g,
600	STARTSWITH_ROMANESQUE_REGEXP: /^[&a-zA-Z\u0590-\u05d4\u05d6-\u05ff\u0080-\u017f\u0400-\u052f\u0370-\u03ff\u1f00-\u1fff\u0600-\u06ff\u200c\u200d\u200e\u0218\u0219\u021a\u021b\u202a-\u202e]/,
601	ENDSWITH_ROMANESQUE_REGEXP: /[.;:&a-zA-Z\u0590-\u05d4\u05d6-\u05ff\u0080-\u017f\u0400-\u052f\u0370-\u03ff\u1f00-\u1fff\u0600-\u06ff\u200c\u200d\u200e\u0218\u0219\u021a\u021b\u202a-\u202e]$/,
602	ALL_ROMANESQUE_REGEXP: /^[a-zA-Z\u0590-\u05ff\u0080-\u017f\u0400-\u052f\u0370-\u03ff\u1f00-\u1fff\u0600-\u06ff\u200c\u200d\u200e\u0218\u0219\u021a\u021b\u202a-\u202e]+$/,
603	VIETNAMESE_SPECIALS: /[\u00c0-\u00c3\u00c8-\u00ca\u00cc\u00cd\u00d2-\u00d5\u00d9\u00da\u00dd\u00e0-\u00e3\u00e8-\u00ea\u00ec\u00ed\u00f2-\u00f5\u00f9\u00fa\u00fd\u0101\u0103\u0110\u0111\u0128\u0129\u0168\u0169\u01a0\u01a1\u01af\u01b0\u1ea0-\u1ef9]/,
604	VIETNAMESE_NAMES: /^(?:(?:[.AaBbCcDdEeGgHhIiKkLlMmNnOoPpQqRrSsTtUuVvXxYy \u00c0-\u00c3\u00c8-\u00ca\u00cc\u00cd\u00d2-\u00d5\u00d9\u00da\u00dd\u00e0-\u00e3\u00e8-\u00ea\u00ec\u00ed\u00f2-\u00f5\u00f9\u00fa\u00fd\u0101\u0103\u0110\u0111\u0128\u0129\u

6040168\u0169\u01a0\u01a1\u01af\u01b0\u1ea0-\u1ef9]{2,6})(\s+|$))+$/,
605	NOTE_FIELDS_REGEXP: /\{:(?:[\-_a-z]+|[A-Z]+):[^\}]+\}/g,
606	NOTE_FIELD_REGEXP: /\{:([\-_a-z]+|[A-Z]+):\s*([^\}]+)\}/,
607	DISPLAY_CLASSES: ["block", "left-margin", "right-inline", "indent"],
608	NAME_VARIABLES: [
609		"author",
610		"editor",
611		"translator",
612		"contributor",
613		"collection-editor",
614		"composer",
615		"container-author",
616		"director",
617		"editorial-director",
618		"interviewer",
619		"original-author",
620		"recipient"
621	],
622	NUMERIC_VARIABLES: [
623		"call-number",
624		"chapter-number",
625		"collection-number",
626		"edition",
627		"page",
628		"issue",
629		"locator",
630		"number",
631		"number-of-pages",
632		"number-of-volumes",
633		"volume",
634		"citation-number"
635	],
636	DATE_VARIABLES: [
637		"locator-date",
638		"issued",
639		"event-date",
640		"accessed",
641		"container",
642		"original-date",
643		"publication-date",
644		"original-date",
645		"available-date",
646		"submitted"
647	],
648	TAG_ESCAPE: function (str) {
649		var mx, lst, len, pos, m, buf1, buf2, idx, ret, myret;
650		mx = str.match(/((?:\"|\')|(?:(?:<span\s+class=\"no(?:case|decor)\">).*?(?:<\/span>|<\/?(?:i|sc|b)>)))/g);
651		lst = str.split(/(?:(?:\"|\')|(?:(?:<span\s+class=\"no(?:case|decor)\">).*?(?:<\/span>|<\/?(?:i|sc|b)>)))/g);
652		myret = [lst[0]];
653		for (pos = 1, len = lst.length; pos < len; pos += 1) {
654			myret.push(mx[pos - 1]);
655			myret.push(lst[pos]);
656		}
657		lst = myret.slice();
658		return lst;
659	},
660	TAG_USEALL: function (str) {
661		var ret, open, close, end;
662		ret = [""];
663		open = str.indexOf("<");
664		close = str.indexOf(">");
665		while (open > -1 && close > -1) {
666			if (open > close) {
667				end = open + 1;
668			} else {
669				end = close + 1;
670			}
671			if (open < close && str.slice(open + 1, close).indexOf("<") === -1) {
672				ret[ret.length - 1] += str.slice(0, open);
673				ret.push(str.slice(open, close + 1));
674				ret.push("");
675				str = str.slice(end);
676			} else {
677				ret[ret.length - 1] += str.slice(0, close + 1);
678				str = str.slice(end);
679			}
680			open = str.indexOf("<");
681			close = str.indexOf(">");
682		}
683		ret[ret.length - 1] += str;
684		return ret;
685	},
686	SKIP_WORDS: ["about","above","across","afore","after","against","along","alongside","amid","amidst","among","amongst","anenst","apropos","apud","around","as","aside","astride","at","athwart","atop","barring","before","behind","below","beneath","beside","besides","between","beyond","but","by","circa","despite","down","during","except","for","forenenst","from","given","in","inside","into","lest","like","modulo","near","next","notwithstanding","of","off","on","onto","out","over","per","plus","pro","qua","sans","since","than","through"," thru","throughout","thruout","till","to","toward","towards","under","underneath","until","unto","up","upon","versus","vs.","v.","vs","v","via","vis-à-vis","with","within","without","according to","ahead of","apart from","as for","as of","as per","as regards","aside from","back to","because of","close to","due to","except for","far from","inside of","instead of","near to","next to","on to","out from","out of","outside of","prior to","pursuant to","rather than","regardless of","such as","that of","up to","where as","or", "yet", "so", "for", "and", "nor", "a", "an", "the", "de", "d'", "von", "van", "c", "et", "ca"],
687	FORMAT_KEY_SEQUENCE: [
688		"@strip-periods",
689		"@font-style",
690		"@font-variant",
691		"@font-weight",
692		"@text-decoration",
693		"@vertical-align",
694		"@quotes"
695	],
696	INSTITUTION_KEYS: [
697		"font-style",
698		"font-variant",
699		"font-weight",
700		"text-decoration",
701		"text-case"
702	],
703	SUFFIX_CHARS: "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z",
704	ROMAN_NUMERALS: [
705		[ "", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix" ],
706		[ "", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc" ],
707		[ "", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm" ],
708		[ "", "m", "mm", "mmm", "mmmm", "mmmmm"]
709	],
710	CREATORS: [
711		"author",
712		"editor",
713		"contributor",
714		"translator",
715		"recipient",
716		"interviewer",
717		"composer",
718		"original-author",
719		"container-author",
720		"collection-editor"
721	],
722	LANGS: {
723		"af-ZA":"Afrikaans",
724		"ar-AR":"Arabic",
725		"bg-BG":"Bulgarian",
726		"ca-AD":"Catalan",
727		"cs-CZ":"Czech",
728		"da-DK":"Danish",
729		"de-AT":"Austrian",
730		"de-CH":"German (CH)",
731		"de-DE":"German (DE)",
732		"el-GR":"Greek",
733		"en-GB":"English (GB)",
734		"en-US":"English (US)",
735		"es-ES":"Spanish",
736		"et-EE":"Estonian",
737		"eu":"European",
738		"fa-IR":"Persian",
739		"fi-FI":"Finnish",
740		"fr-CA":"French (CA)",
741		"fr-FR":"French (FR)",
742		"he-IL":"Hebrew",
743		"hr-HR":"Croatian",
744		"hu-HU":"Hungarian",
745		"is-IS":"Icelandic",
746		"it-IT":"Italian",
747		"ja-JP":"Japanese",
748		"km-KH":"Khmer",
749		"ko-KR":"Korean",
750		"lt-LT":"Lithuanian",
751		"lv-LV":"Latvian",
752		"mn-MN":"Mongolian",
753		"nb-NO":"Norwegian (Bokmål)",
754		"nl-NL":"Dutch",
755		"nn-NO":"Norwegian (Nynorsk)",
756		"pl-PL":"Polish",
757		"pt-BR":"Portuguese (BR)",
758		"pt-PT":"Portuguese (PT)",
759		"ro-RO":"Romanian",
760		"ru-RU":"Russian",
761		"sk-SK":"Slovak",
762		"sl-SI":"Slovenian",
763		"sr-RS":"Serbian",
764		"sv-SE":"Swedish",
765		"th-TH":"Thai",

766		"tr-TR":"Turkish",
767		"uk-UA":"Ukranian",
768		"vi-VN":"Vietnamese",
769		"zh-CN":"Chinese (CN)",
770		"zh-TW":"Chinese (TW)"
771	},
772	LANG_BASES: {
773		af: "af_ZA",
774		ar: "ar_AR",
775		bg: "bg_BG",
776		ca: "ca_AD",
777		cs: "cs_CZ",
778		da: "da_DK",
779		de: "de_DE",
780		el: "el_GR",
781		en: "en_US",
782		es: "es_ES",
783		et: "et_EE",
784		eu: "eu",
785		fa: "fa_IR",
786		fi: "fi_FI",
787		fr: "fr_FR",
788		he: "he_IL",
789		hu: "hu_HU",
790		is: "is_IS",
791		it: "it_IT",
792		ja: "ja_JP",
793		km: "km_KH",
794		ko: "ko_KR",
795		lt: "lt_LT",
796		mn: "mn_MN",
797		nb: "nb_NO",
798		nl: "nl_NL",
799		nn: "nn-NO",
800		pl: "pl_PL",
801		pt: "pt_PT",
802		ro: "ro_RO",
803		ru: "ru_RU",
804		sk: "sk_SK",
805		sl: "sl_SI",
806		sr: "sr_RS",
807		sv: "sv_SE",
808		th: "th_TH",
809		tr: "tr_TR",
810		uk: "uk_UA",
811		vi: "vi_VN",
812		zh: "zh_CN"
813	},
814	SUPERSCRIPTS: {
815		"\u00AA": "\u0061",
816		"\u00B2": "\u0032",
817		"\u00B3": "\u0033",
818		"\u00B9": "\u0031",
819		"\u00BA": "\u006F",
820		"\u02B0": "\u0068",
821		"\u02B1": "\u0266",
822		"\u02B2": "\u006A",
823		"\u02B3": "\u0072",
824		"\u02B4": "\u0279",
825		"\u02B5": "\u027B",
826		"\u02B6": "\u0281",
827		"\u02B7": "\u0077",
828		"\u02B8": "\u0079",
829		"\u02E0": "\u0263",
830		"\u02E1": "\u006C",
831		"\u02E2": "\u0073",
832		"\u02E3": "\u0078",
833		"\u02E4": "\u0295",
834		"\u1D2C": "\u0041",
835		"\u1D2D": "\u00C6",
836		"\u1D2E": "\u0042",
837		"\u1D30": "\u0044",
838		"\u1D31": "\u0045",
839		"\u1D32": "\u018E",
840		"\u1D33": "\u0047",
841		"\u1D34": "\u0048",
842		"\u1D35": "\u0049",
843		"\u1D36": "\u004A",
844		"\u1D37": "\u004B",
845		"\u1D38": "\u004C",
846		"\u1D39": "\u004D",
847		"\u1D3A": "\u004E",
848		"\u1D3C": "\u004F",
849		"\u1D3D": "\u0222",
850		"\u1D3E": "\u0050",
851		"\u1D3F": "\u0052",
852		"\u1D40": "\u0054",
853		"\u1D41": "\u0055",
854		"\u1D42": "\u0057",
855		"\u1D43": "\u0061",
856		"\u1D44": "\u0250",
857		"\u1D45": "\u0251",
858		"\u1D46": "\u1D02",
859		"\u1D47": "\u0062",
860		"\u1D48": "\u0064",
861		"\u1D49": "\u0065",
862		"\u1D4A": "\u0259",
863		"\u1D4B": "\u025B",
864		"\u1D4C": "\u025C",
865		"\u1D4D": "\u0067",
866		"\u1D4F": "\u006B",
867		"\u1D50": "\u006D",
868		"\u1D51": "\u014B",
869		"\u1D52": "\u006F",
870		"\u1D53": "\u0254",
871		"\u1D54": "\u1D16",
872		"\u1D55": "\u1D17",
873		"\u1D56": "\u0070",
874		"\u1D57": "\u0074",
875		"\u1D58": "\u0075",
876		"\u1D59": "\u1D1D",
877		"\u1D5A": "\u026F",
878		"\u1D5B": "\u0076",
879		"\u1D5C": "\u1D25",
880		"\u1D5D": "\u03B2",
881		"\u1D5E": "\u03B3",
882		"\u1D5F": "\u03B4",
883		"\u1D60": "\u03C6",
884		"\u1D61": "\u03C7",
885		"\u2070": "\u0030",
886		"\u2071": "\u0069",
887		"\u2074": "\u0034",
888		"\u2075": "\u0035",
889		"\u2076": "\u0036",
890		"\u2077": "\u0037",
891		"\u2078": "\u0038",
892		"\u2079": "\u0039",
893		"\u207A": "\u002B",
894		"\u207B": "\u2212",
895		"\u207C": "\u003D",
896		"\u207D": "\u0028",
897		"\u207E": "\u0029",
898		"\u207F": "\u006E",
899		"\u2120": "\u0053\u004D",
900		"\u2122": "\u0054\u004D",
901		"\u3192": "\u4E00",
902		"\u3193": "\u4E8C",
903		"\u3194": "\u4E09",
904		"\u3195": "\u56DB",
905		"\u3196": "\u4E0A",
906		"\u3197": "\u4E2D",
907		"\u3198": "\u4E0B",
908		"\u3199": "\u7532",
909		"\u319A": "\u4E59",
910		"\u319B": "\u4E19",
911		"\u319C": "\u4E01",
912		"\u319D": "\u5929",
913		"\u319E": "\u5730",
914		"\u319F": "\u4EBA",
915		"\u02C0": "\u0294",
916		"\u02C1": "\u0295",
917		"\u06E5": "\u0648",
918		"\u06E6": "\u064A"
919	},
920	SUPERSCRIPTS_REGEXP: new RegExp("[\u00AA\u00B2\u00B3\u00B9\u00BA\u02B0\u02B1\u02B2\u02B3\u02B4\u02B5\u02B6\u02B7\u02B8\u02E0\u02E1\u02E2\u02E3\u02E4\u1D2C\u1D2D\u1D2E\u1D30\u1D31\u1D32\u1D33\u1D34\u1D35\u1D36\u1D37\u1D38\u1D39\u1D3A\u1D3C\u1D3D\u1D3E\u1D3F\u1D40\u1D41\u1D42\u1D43\u1D44\u1D45\u1D46\u1D47\u1D48\u1D49\u1D4A\u1D4B\u1D4C\u1D4D\u1D4F\u1D50\u1D51\u1D52\u1D53\u1D54\u1D55\u1D56\u1D57\u1D58\u1D59\u1D5A\u1D5B\u1D5C\u1D5D\u1D5E\u1D5F\u1D60\u1D61\u2070\u2071\u2074\u2075\u2076\u2077\u2078\u2079\u207A\u207B\u207C\u207D\u207E\u207F\u2120\u2122\u3192\u3193\u3194\u3195\u3196\u3197\u3198\u3199\u319A\u319B\u319C\u319D\u319E\u319F\u02C0\u02C1\u06E5\u06E6]", "g"),
921	locale: {},
922	locale_opts: {},
923	locale_dates: {}
924};
925if (typeof require !== "undefined" && typeof module !== 'undefined' && "exports" in module) {
926	var CSL_IS_NODEJS = true;
927	var CSL_NODEJS = require("./csl_nodejs_jsdom").CSL_NODEJS_JSDOM;
928	exports.CSL = CSL;
929}
930CSL.TERMINAL_PUNCTUATION_REGEXP = new RegExp("^([" + CSL.TERMINAL_PUNCTUATION.slice(0, -1).join("") + "])(.*)");
931CSL.CLOSURES = new RegExp(".*[\\]\\)]");
932if ("object" === typeof console && "function" === typeof console.log) {
933	CSL.debug = function (str) {
934		console.log("CSL: " + str);
935	};
936	CSL.error = function (str) {
937		console.log("CSL error: " + str);
938	};
939} else {
940	CSL.debug = function () {};
941	CSL.error = function (str) {
942		throw "CSL error: " + str;
943	};
944}
945var XML_PARSING;
946if ("undefined" !== typeof CSL_IS_NODEJS) {
947	XML_PARSING = CSL_NODEJS;
948} else if ("undefined" !== typeof CSL_E4X) {
949	XML_PARSING = CSL_E4X;
950} else if ("undefined" !== typeof CSL_JSON) {
951	XML_PARSING = CSL_JSON;
952} else {
953	XML_PARSING = CSL_CHROME;
954}
955CSL.System = {};
956CSL.System.Xml = {
957	"Parsing": XML_PARSING
958};

959CSL.getSortCompare = function (default_locale) {
960	if (CSL.stringCompare) {
961		return CSL.stringCompare;
962	}
963	var strcmp;
964	var strcmp_opts = {
965		sensitivity:"base",
966		ignorePunctuation:true,
967		numeric:true
968	 }
969	if (!default_locale) {
970		default_locale = "en-US";
971	}
972	strcmp = function (a, b) {
973		return a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase(),default_locale,strcmp_opts);
974	};
975	var stripPunct = function (str) {
976		return str.replace(/^[\[\]\'\"]*/g, "");
977	}
978	var getBracketPreSort = function () {
979		if (!strcmp("[x","x")) {
980			return false;
981		} else {
982			return function (a, b) {
983				return strcmp(stripPunct(a), stripPunct(b));
984			}
985		}
986	}
987	var bracketPreSort = getBracketPreSort();
988	var sortCompare = function (a, b) {
989		if (bracketPreSort) {
990			return bracketPreSort(a, b);
991		} else {
992			return strcmp(a, b);
993		}
994	}
995	return sortCompare;
996};
997CSL.ambigConfigDiff = function(a, b) {
998	var ret, pos, len, ppos, llen;
999	if (a.names.length !== b.names.length) {
1000		return 1;
1001	} else {
1002		for (pos = 0, len = a.names.length; pos < len; pos += 1) {
1003			if (a.names[pos] !== b.names[pos]) {
1004				return 1;
1005			} else {
1006				for (ppos = 0, llen = a.givens[pos]; ppos < llen; ppos += 1) {
1007					if (a.givens[pos][ppos] !== b.givens[pos][ppos]) {
1008						return 1;
1009					}
1010				}
1011			}
1012		}
1013	}
1014	if (a.disambiguate != b.disambiguate) {
1015		return 1;
1016	}
1017	if (a.year_suffix !== b.year_suffix) {
1018		return 1;
1019	}
1020	return 0;
1021};
1022CSL.cloneAmbigConfig = function (config, oldconfig, tainters) {
1023	var i, ilen, j, jlen, k, klen, param;
1024	var ret = {};
1025	ret.names = [];
1026	ret.givens = [];
1027	ret.year_suffix = false;
1028	ret.disambiguate = false;
1029	for (i = 0, ilen = config.names.length; i < ilen; i += 1) {
1030		param = config.names[i];
1031		ret.names[i] = param;
1032	}
1033	for (i  = 0, ilen = config.givens.length; i < ilen; i += 1) {
1034		param = [];
1035		for (j = 0, jlen = config.givens[i].length; j < jlen; j += 1) {
1036			param.push(config.givens[i][j]);
1037		}
1038		ret.givens.push(param);
1039	}
1040	if (oldconfig) {
1041		ret.year_suffix = oldconfig.year_suffix;
1042		ret.disambiguate = oldconfig.disambiguate;
1043	} else {
1044		ret.year_suffix = config.year_suffix;
1045		ret.disambiguate = config.disambiguate;
1046	}
1047	return ret;
1048};
1049CSL.getAmbigConfig = function () {
1050	var config, ret;
1051	config = this.tmp.disambig_request;
1052	if (!config) {
1053		config = this.tmp.disambig_settings;
1054	}
1055	ret = CSL.cloneAmbigConfig(config);
1056	return ret;
1057};
1058CSL.getMaxVals = function () {
1059	return this.tmp.names_max.mystack.slice();
1060};
1061CSL.getMinVal = function () {
1062	return this.tmp["et-al-min"];
1063};
1064CSL.tokenExec = function (token, Item, item) {
1065	var next, maybenext, exec, pos, len, debug;
1066	debug = false;
1067	next = token.next;
1068	maybenext = false;
1069	var record = function (result) {
1070		if (result) {
1071			this.tmp.jump.replace("succeed");
1072			return token.succeed;
1073		} else {
1074			this.tmp.jump.replace("fail");
1075			return token.fail;
1076		}
1077	}
1078	if (token.test) {
1079		next = record.call(this,token.test(Item, item));
1080	}
1081	len = token.execs.length;
1082	for (pos = 0; pos < len; pos += 1) {
1083		exec = token.execs[pos];
1084		maybenext = exec.call(token, this, Item, item);
1085		if (maybenext) {
1086			next = maybenext;
1087		}
1088	}
1089	return next;
1090};
1091CSL.expandMacro = function (macro_key_token) {
1092	var mkey, start_token, key, end_token, navi, macro_nodes, newoutput, mergeoutput, end_of_macro, func;
1093	mkey = macro_key_token.postponed_macro;
1094	if (this.build.macro_stack.indexOf(mkey) > -1) {
1095		throw "CSL processor error: call to macro \"" + mkey + "\" would cause an infinite loop";
1096	} else {
1097		this.build.macro_stack.push(mkey);
1098	}
1099	var hasDate = false;
1100	var macroid = false;
1101	macro_nodes = this.sys.xml.getNodesByName(this.cslXml, 'macro', mkey);
1102	if (macro_nodes.length) {
1103		macroid = this.sys.xml.getAttributeValue(macro_nodes[0],'cslid');
1104		hasDate = this.sys.xml.getAttributeValue(macro_nodes[0], "macro-has-date");
1105	}
1106	if (hasDate) {
1107		func = function (state, Item) {
1108			if (state.tmp.extension) {
1109				state.tmp["doing-macro-with-date"] = true;
1110			}
1111		};
1112		macro_key_token.execs.push(func);
1113	}
1114	macro_key_token.tokentype = CSL.START;
1115	macro_key_token.cslid = macroid;
1116	CSL.Node.group.build.call(macro_key_token, this, this[this.build.area].tokens, true);
1117	if (!this.sys.xml.getNodeValue(macro_nodes)) {
1118		throw "CSL style error: undefined macro \"" + mkey + "\"";
1119	}
1120	var builder = CSL.makeBuilder(this);
1121	builder(macro_nodes[0]);
1122	end_of_macro = new CSL.Token("group", CSL.END);
1123	if (macro_key_token.decorations) {
1124		end_of_macro.decorations = macro_key_token.decorations.slice();
1125	}
1126	if (hasDate) {
1127		func = function (state, Item) {
1128			if (state.tmp.extension) {
1129				state.tmp["doing-macro-with-date"] = false;

1130			}
1131		};
1132		end_of_macro.execs.push(func);
1133	}
1134	CSL.Node.group.build.call(end_of_macro, this, this[this.build.area].tokens, true);
1135	this.build.macro_stack.pop();
1136};
1137CSL.XmlToToken = function (state, tokentype) {
1138	var name, txt, attrfuncs, attributes, decorations, token, key, target;
1139	name = state.sys.xml.nodename(this);
1140	if (state.build.skip && state.build.skip !== name) {
1141		return;
1142	}
1143	if (!name) {
1144		txt = state.sys.xml.content(this);
1145		if (txt) {
1146			state.build.text = txt;
1147		}
1148		return;
1149	}
1150	if (!CSL.Node[state.sys.xml.nodename(this)]) {
1151		throw "Undefined node name \"" + name + "\".";
1152	}
1153	attrfuncs = [];
1154	attributes = state.sys.xml.attributes(this);
1155	decorations = CSL.setDecorations.call(this, state, attributes);
1156	token = new CSL.Token(name, tokentype);
1157	if (tokentype !== CSL.END || name === "if" || name === "else-if" || name === "layout") {
1158		for (key in attributes) {
1159			if (attributes.hasOwnProperty(key)) {
1160				if (tokentype === CSL.END && key !== "@language" && key !== "@locale") {
1161					continue;
1162				}
1163				if (attributes.hasOwnProperty(key)) {
1164					if (CSL.Attributes[key]) {
1165						try {
1166							CSL.Attributes[key].call(token, state, "" + attributes[key]);
1167						} catch (e) {
1168							CSL.error(e);
1169							throw "CSL processor error, " + key + " attribute: " + e;
1170						}
1171					} else {
1172						CSL.debug("warning: undefined attribute \""+key+"\" in style");
1173					}
1174				}
1175			}
1176		}
1177		token.decorations = decorations;
1178	} else if (tokentype === CSL.END && attributes['@variable']) {
1179		token.hasVariable = true;
1180	}
1181	target = state[state.build.area].tokens;
1182	CSL.Node[name].build.call(token, state, target);
1183};
1184CSL.DateParser = function () {
1185	var jiy_list, jiy, jiysplitter, jy, jmd, jr, pos, key, val, yearlast, yearfirst, number, rangesep, fuzzychar, chars, rex, rexdash, rexdashslash, rexslashdash, seasonstrs, seasonrexes, seasonstr, monthstrs, monthstr, mrexes, seasonrex, len, jiymatchstring, jiymatcher;
1186	jiy_list = [
1187		["\u660E\u6CBB", 1867],
1188		["\u5927\u6B63", 1911],
1189		["\u662D\u548C", 1925],
1190		["\u5E73\u6210", 1988]
1191	];
1192	jiy = {};
1193	len = jiy_list.length;
1194	for (pos = 0; pos < len; pos += 1) {
1195		key = jiy_list[pos][0];
1196		val = jiy_list[pos][1];
1197		jiy[key] = val;
1198	}
1199	jiymatchstring = [];
1200	for (pos = 0; pos < len; pos += 1) {
1201		val = jiy_list[pos][0];
1202		jiymatchstring.push(val);
1203	}
1204	jiymatchstring = jiymatchstring.join("|");
1205	jiysplitter = "(?:" + jiymatchstring + ")(?:[0-9]+)";
1206	jiysplitter = new RegExp(jiysplitter);
1207	jiymatcher = "(?:" + jiymatchstring + ")(?:[0-9]+)";
1208	jiymatcher = new RegExp(jiymatcher, "g");
1209	jmd = /(\u6708|\u5E74)/g;
1210	jy = /\u65E5/;
1211	jr = /\u301c/g;
1212	yearlast = "(?:[?0-9]{1,2}%%NUMD%%){0,2}[?0-9]{4}(?![0-9])";
1213	yearfirst = "[?0-9]{4}(?:%%NUMD%%[?0-9]{1,2}){0,2}(?![0-9])";
1214	number = "[?0-9]{1,3}";
1215	rangesep = "[%%DATED%%]";
1216	fuzzychar = "[?~]";
1217	chars = "[a-zA-Z]+";
1218	rex = "(" + yearfirst + "|" + yearlast + "|" + number + "|" + rangesep + "|" + fuzzychar + "|" + chars + ")";
1219	rexdash = new RegExp(rex.replace(/%%NUMD%%/g, "-").replace(/%%DATED%%/g, "-"));
1220	rexdashslash = new RegExp(rex.replace(/%%NUMD%%/g, "-").replace(/%%DATED%%/g, "\/"));
1221	rexslashdash = new RegExp(rex.replace(/%%NUMD%%/g, "\/").replace(/%%DATED%%/g, "-"));
1222	seasonstrs = [];
1223	seasonrexes = [];
1224	len = seasonstrs.length;
1225	for (pos = 0; pos < len; pos += 1) {
1226		seasonrex = new RegExp(seasonstrs[pos] + ".*");
1227		seasonrexes.push(seasonrex);
1228	}
1229	this.mstrings = "january february march april may june july august september october november december spring summer fall winter spring summer";
1230	this.mstrings = this.mstrings.split(" ");
1231	this.setOrderDayMonth = function() {
1232		this.monthguess = 1;
1233		this.dayguess = 0;
1234	};
1235	this.setOrderMonthDay = function() {
1236		this.monthguess = 0;
1237		this.dayguess = 1;
1238	};
1239	this.setOrderMonthDay();
1240	this.resetMonths = function() {
1241		var i, ilen, j, jlen;
1242		this.msets = [];
1243		for (i = 0, ilen = this.mstrings.length; i < ilen; i += 1) {
1244			this.msets.push([this.mstrings[i]]);
1245		}
1246		this.mabbrevs = [];
1247		for (i = 0, ilen = this.msets.length; i < ilen; i += 1) {
1248			this.mabbrevs.push([]);
1249			for (j = 0, jlen = this.msets[i].length; j < jlen; j += 1) {
1250				this.mabbrevs[i].push(this.msets[i][0].slice(0, 3));
1251			}
1252		}
1253		this.mrexes = [];
1254		for (i = 0, ilen = this.mabbrevs.length; i < ilen; i += 1) {
1255			this.mrexes.push(new RegExp("(?:" + this.mabbrevs[i].join("|") + ")"));
1256		}
1257	};
1258	this.resetMonths();
1259	this.addMonths = function(lst) {
1260		var i, ilen, j, jlen, k, klen, jkey, kkey;
1261		if ("string" === typeof lst) {
1262			lst = lst.split(/\s+/);
1263		}
1264		if (lst.length !== 12 && lst.length !== 16) {
1265			CSL.debug("month [+season] list of "+lst.length+", expected 12 or 16. Ignoring.");
1266			return;
1267		}
1268		var othermatch = [];
1269		var thismatch = [];
1270		for (i = 0, ilen = lst.length; i < ilen; i += 1) {
1271			var abbrevlen = false;

1272			var skip = false;
1273			var insert = 3;
1274			var extend = {};
1275			for (j = 0, jlen = this.mabbrevs.length; j < jlen; j += 1) {
1276				extend[j] = {};
1277				if (j === i) {
1278					for (k = 0, klen = this.mabbrevs[i].length; k < klen; k += 1) {
1279						if (this.mabbrevs[i][k] === lst[i].slice(0, this.mabbrevs[i][k].length)) {
1280							skip = true;
1281							break;
1282						}
1283					}
1284				} else {
1285					for (k = 0, klen = this.mabbrevs[j].length; k < klen; k += 1) {
1286						abbrevlen = this.mabbrevs[j][k].length;
1287						if (this.mabbrevs[j][k] === lst[i].slice(0, abbrevlen)) {
1288							while (this.msets[j][k].slice(0, abbrevlen) === lst[i].slice(0, abbrevlen)) {
1289								if (abbrevlen > lst[i].length || abbrevlen > this.msets[j][k].length) {
1290									CSL.debug("unable to disambiguate month string in date parser: "+lst[i]);
1291									break;
1292								} else {
1293									abbrevlen += 1;
1294								}
1295							}
1296							insert = abbrevlen;
1297							extend[j][k] = abbrevlen;
1298						}
1299					}
1300				}
1301				for (jkey in extend) {
1302					if (extend.hasOwnProperty(jkey)) {
1303						for (kkey in extend[jkey]) {
1304							if (extend[jkey].hasOwnProperty(kkey)) {
1305								abbrevlen = extend[jkey][kkey];
1306								jkey = parseInt(jkey, 10);
1307								kkey = parseInt(kkey, 10);
1308								this.mabbrevs[jkey][kkey] = this.msets[jkey][kkey].slice(0, abbrevlen);
1309							}
1310						}
1311					}
1312				}
1313			}
1314			if (!skip) {
1315				this.msets[i].push(lst[i]);
1316				this.mabbrevs[i].push(lst[i].slice(0, insert));
1317			}
1318		}
1319		this.mrexes = [];
1320		for (i = 0, ilen = this.mabbrevs.length; i < ilen; i += 1) {
1321			this.mrexes.push(new RegExp("(?:" + this.mabbrevs[i].join("|") + ")"));
1322		}
1323	};
1324	this.parse = function (txt) {
1325		var slash, dash, lst, l, m, number, note, thedate, slashcount, range_delim, date_delim, ret, delim_pos, delims, isrange, suff, date, breakme, item, delim, element, mm, slst, mmpos, i, ilen, j, jlen, k, klen;
1326	if (txt) {
1327		txt = "" + txt;
1328		txt = txt.replace(/\s*[0-9]{2}:[0-9]{2}(?::[0-9]+)/,"");
1329		m = txt.match(jmd);
1330		if (m) {
1331			txt = txt.replace(/\s+/, "", "g");
1332			txt = txt.replace(jy, "", "g");
1333			txt = txt.replace(jmd, "-", "g");
1334			txt = txt.replace(jr, "/", "g");
1335			txt = txt.replace("-/", "/", "g");
1336			txt = txt.replace(/-$/,"", "g");
1337			slst = txt.split(jiysplitter);
1338			lst = [];
1339			mm = txt.match(jiymatcher);
1340			if (mm) {
1341				var mmx = [];
1342				for (pos = 0, len = mm.length; pos < len; pos += 1) {
1343					mmx = mmx.concat(mm[pos].match(/([^0-9]+)([0-9]+)/).slice(1));
1344				}
1345				for (pos = 0, len = slst.length; pos < len; pos += 1) {
1346					lst.push(slst[pos]);
1347					if (pos !== (len - 1)) {
1348						mmpos = (pos * 2);
1349						lst.push(mmx[mmpos]);
1350						lst.push(mmx[mmpos + 1]);
1351					}
1352				}
1353			} else {
1354				lst = slst;
1355			}
1356			l = lst.length;
1357			for    (pos = 1; pos < l; pos += 3) {
1358				lst[pos + 1] = jiy[lst[pos]] + parseInt(lst[pos + 1], 10);
1359				lst[pos] = "";
1360			}
1361			txt = lst.join("");
1362			txt = txt.replace(/\s*-\s*$/, "").replace(/\s*-\s*\//, "/");
1363			txt = txt.replace(/\.\s*$/, "");
1364			txt = txt.replace(/\.(?! )/, "");
1365			slash = txt.indexOf("/");
1366			dash = txt.indexOf("-");
1367		}
1368	}
1369		txt = txt.replace(/([A-Za-z])\./g, "$1");
1370		number = "";
1371		note = "";
1372		thedate = {};
1373		if (txt.slice(0, 1) === "\"" && txt.slice(-1) === "\"") {
1374			thedate.literal = txt.slice(1, -1);
1375			return thedate;
1376		}
1377		if (slash > -1 && dash > -1) {
1378			slashcount = txt.split("/");
1379			if (slashcount.length > 3) {
1380				range_delim = "-";
1381				date_delim = "/";
1382				lst = txt.split(rexslashdash);
1383			} else {
1384				range_delim = "/";
1385				date_delim = "-";
1386				lst = txt.split(rexdashslash);
1387			}
1388		} else {
1389			txt = txt.replace("/", "-");
1390			range_delim = "-";
1391			date_delim = "-";
1392			lst = txt.split(rexdash);
1393		}
1394		ret = [];
1395		len = lst.length;
1396		for (pos = 0; pos < len; pos += 1) {
1397			item = lst[pos];
1398			m = item.match(/^\s*([\-\/]|[a-zA-Z]+|[\-~?0-9]+)\s*$/);
1399			if (m) {
1400				ret.push(m[1]);
1401			}
1402		}
1403		delim_pos = ret.indexOf(range_delim);
1404		delims = [];
1405		isrange = false;
1406		if (delim_pos > -1) {
1407			delims.push([0, delim_pos]);
1408			delims.push([(delim_pos + 1), ret.length]);
1409			isrange = true;
1410		} else {
1411			delims.push([0, ret.length]);
1412		}
1413		suff = "";
1414		for (i = 0, ilen = delims.length; i < ilen; i += 1) {
1415			delim = delims[i];
1416			date = ret.slice(delim[0], delim[1]);
1417			for (j = 0, jlen = date.length; j < jlen; j += 1) {
1418				element = date[j];
1419				if (element.indexOf(date_delim) > -1) {
1420					this.parseNumericDate(thedate, date_delim, suff, element);
1421					continue;
1422				}
1423				if (element.match(/[0-9]{4}/)) {
1424					thedate[("year" + suff)] = element.replace(/^0*/, "");
1425					continue;
1426				}
1427				breakme = false;

1428				for (k = 0, klen = this.mrexes.length; k < klen; k += 1) {
1429					if (element.toLocaleLowerCase().match(this.mrexes[k])) {
1430						thedate[("month" + suff)] = "" + (parseInt(k, 10) + 1);
1431						breakme = true;
1432						break;
1433					}
1434					if (breakme) {
1435						continue;
1436					}
1437					if (element.match(/^[0-9]+$/)) {
1438						number = parseInt(element, 10);
1439					}
1440					if (element.toLocaleLowerCase().match(/^bc/) && number) {
1441						thedate[("year" + suff)] = "" + (number * -1);
1442						number = "";
1443						continue;
1444					}
1445					if (element.toLocaleLowerCase().match(/^ad/) && number) {
1446						thedate[("year" + suff)] = "" + number;
1447						number = "";
1448						continue;
1449					}
1450				}
1451				breakme = false;
1452				for (k = 0, klen = seasonrexes.length; k < klen; k += 1) {
1453					if (element.toLocaleLowerCase().match(seasonrexes[k])) {
1454						thedate[("season" + suff)] = "" + (parseInt(k, 10) + 1);
1455						breakme = true;
1456						break;
1457					}
1458				}
1459				if (breakme) {
1460					continue;
1461				}
1462				if (element === "~" || element === "?" || element === "c" || element.match(/^cir/)) {
1463					thedate.circa = "" + 1;
1464					continue;
1465				}
1466				if (element.toLocaleLowerCase().match(/(?:mic|tri|hil|eas)/) && !thedate[("season" + suff)]) {
1467					note = element;
1468					continue;
1469				}
1470			}
1471			if (number) {
1472				thedate[("day" + suff)] = number;
1473				number = "";
1474			}
1475			if (note && !thedate[("season" + suff)]) {
1476				thedate[("season" + suff)] = note;
1477				note = "";
1478			}
1479			suff = "_end";
1480		}
1481		if (isrange) {
1482			for (j = 0, jlen = CSL.DATE_PARTS_ALL.length; j < jlen; j += 1) {
1483				item = CSL.DATE_PARTS_ALL[j];
1484				if (thedate[item] && !thedate[(item + "_end")]) {
1485					thedate[(item + "_end")] = thedate[item];
1486				} else if (!thedate[item] && thedate[(item + "_end")]) {
1487					thedate[item] = thedate[(item + "_end")];
1488				}
1489			}
1490		}
1491		if (!thedate.year) {
1492			thedate = { "literal": txt };
1493		}
1494		if (this.use_array) {
1495			this.toArray(thedate);
1496		}
1497		return thedate;
1498	};
1499	this.returnAsArray = function () {
1500		this.use_array = true;
1501	};
1502	this.returnAsKeys = function () {
1503		this.use_array = false;
1504	};
1505	this.toArray = function (thedate) {
1506		var i, ilen, part;
1507		thedate["date-parts"] = [];
1508		thedate["date-parts"].push([]);
1509		var slicelen = 0;
1510		for (i = 0, ilen = 3; i < ilen; i += 1) {
1511			part = ["year", "month", "day"][i];
1512			if (!thedate[part]) {
1513				break;
1514			}
1515			slicelen += 1;
1516			thedate["date-parts"][0].push(thedate[part]);
1517			delete thedate[part];
1518		}
1519		thedate["date-parts"].push([]);
1520		for (i = 0, ilen = slicelen; i < ilen; i += 1) {
1521			part = ["year_end", "month_end", "day_end"][i];
1522			if (!thedate[part]) {
1523				break;
1524			}
1525			thedate["date-parts"][1].push(thedate[part]);
1526			delete thedate[part];
1527		}
1528		if (thedate["date-parts"][0].length !== thedate["date-parts"][1].length) {
1529			thedate["date-parts"].pop();
1530		}
1531	};
1532	this.parseNumericDate = function (ret, delim, suff, txt) {
1533		var lst, i, ilen;
1534		lst = txt.split(delim);
1535		for (i = 0, ilen = lst.length; i < ilen; i += 1) {
1536			if (lst[i].length === 4) {
1537				ret[("year" + suff)] = lst[i].replace(/^0*/, "");
1538				if (!i) {
1539					lst = lst.slice(1);
1540				} else {
1541					lst = lst.slice(0, i);
1542				}
1543				break;
1544			}
1545		}
1546		for (i = 0, ilen = lst.length; i < ilen; i += 1) {
1547			lst[i] = parseInt(lst[i], 10);
1548		}
1549		if (lst.length === 1 || (lst.length === 2 && !lst[1])) {
1550			ret[("month" + suff)] = "" + lst[0];
1551		} else if (lst.length === 2) {
1552			if (lst[this.monthguess] > 12) {
1553				ret[("month" + suff)] = "" + lst[this.dayguess];
1554				ret[("day" + suff)] = "" + lst[this.monthguess];
1555			} else {
1556				ret[("month" + suff)] = "" + lst[this.monthguess];
1557				ret[("day" + suff)] = "" + lst[this.dayguess];
1558			}
1559		}
1560	};
1561};
1562CSL.Engine = function (sys, style, lang, forceLang) {
1563	var attrs, langspec, localexml, locale;
1564	this.processor_version = CSL.PROCESSOR_VERSION;
1565	this.csl_version = "1.0";
1566	this.sys = sys;
1567	if (sys.variableWrapper) {
1568		CSL.VARIABLE_WRAPPER_PREPUNCT_REX = new RegExp('^([' + [" "].concat(CSL.SWAPPING_PUNCTUATION).join("") + ']*)(.*)');
1569	}
1570	this.sys.xml = new CSL.System.Xml.Parsing();
1571	if ("undefined" === typeof CSL_JSON && "string" !== typeof style) {
1572		style = "";
1573	}
1574	if (CSL.getAbbreviation) {
1575		this.sys.getAbbreviation = CSL.getAbbreviation;
1576	}
1577	if (this.sys.stringCompare) {
1578		CSL.stringCompare = this.sys.stringCompare;
1579	}
1580	this.sys.AbbreviationSegments = CSL.AbbreviationSegments;
1581	this.parallel = new CSL.Parallel(this);
1582	this.transform = new CSL.Transform(this);
1583	this.setParseNames = function (val) {
1584		this.opt['parse-names'] = val;
1585	};
1586	this.opt = new CSL.Engine.Opt();
1587	this.tmp = new CSL.Engine.Tmp();
1588	this.build = new CSL.Engine.Build();
1589	this.fun = new CSL.Engine.Fun(this);
1590	this.configure = new CSL.Engine.Configure();
1591	this.citation_sort = new CSL.Engine.CitationSort();
1592	this.bibliography_sort = new CSL.Engine.BibliographySort();
1593	this.citation = new CSL.Engine.Citation(this);
1594	this.bibliography = new CSL.Engine.Bibliography();
1595	this.output = new CSL.Output.Queue(this);
1596	this.dateput = new CSL.Output.Queue(this);
1597	this.cslXml = this.sys.xml.makeXml(style);
1598	if (this.opt.development_extensions.csl_reverse_lookup_support || this.sys.csl_reverse_lookup_support) {
1599		this.build.cslNodeId = 0;
1600		this.setCslNodeIds = function(myxml, nodename) {
1601			var children = this.sys.xml.children(myxml);
1602			this.sys.xml.setAttribute(myxml, 'cslid', this.build.cslNodeId);
1603			this.opt.nodenames.push(nodename);
1604			this.build.cslNodeId += 1;
1605			for (var i = 0, ilen = this.sys.xml.numberofnodes(children); i < ilen; i += 1) {
1606				nodename = this.sys.xml.nodename(children[i]);
1607				if (nodename) {
1608					this.setCslNodeIds(children[i], nodename);
1609				}
1610			}
1611		};
1612		this.setCslNodeIds(this.cslXml, "style");
1613	}
1614	this.sys.xml.addMissingNameNodes(this.cslXml);
1615	this.sys.xml.addInstitutionNodes(this.cslXml);
1616	this.sys.xml.insertPublisherAndPlace(this.cslXml);
1617	this.sys.xml.flagDateMacros(this.cslXml);
1618	attrs = this.sys.xml.attributes(this.cslXml);
1619	if ("undefined" === typeof attrs["@sort-separator"]) {
1620		this.sys.xml.setAttribute(this.cslXml, "sort-separator", ", ");
1621	}
1622	this.opt["initialize-with-hyphen"] = true;
1623	this.setStyleAttributes();
1624	this.opt.xclass = sys.xml.getAttributeValue(this.cslXml, "class");
1625	this.opt.styleID = this.sys.xml.getStyleId(this.cslXml);
1626	this.opt.styleName = this.sys.xml.getStyleId(this.cslXml, true);

1627	if (CSL.getSuppressJurisdictions) {
1628		this.opt.suppressJurisdictions = CSL.getSuppressJurisdictions(this.opt.styleID);
1629	}
1630	if (this.opt.version.slice(0,4) === "1.1m") {
1631		this.opt.development_extensions.static_statute_locator = true;
1632		this.opt.development_extensions.handle_parallel_articles = true;
1633		this.opt.development_extensions.main_title_from_short_title = true;
1634		this.opt.development_extensions.strict_page_numbers = true;
1635		this.opt.development_extensions.rtl_support = true;
1636		this.opt.development_extensions.expect_and_symbol_form = true;
1637		this.opt.development_extensions.require_explicit_legal_case_title_short = true;
1638	}
1639	if (lang) {
1640		lang = lang.replace("_", "-");
1641	}
1642	if (this.opt["default-locale"][0]) {
1643		this.opt["default-locale"][0] = this.opt["default-locale"][0].replace("_", "-");
1644	}
1645	if (lang && forceLang) {
1646		this.opt["default-locale"] = [lang];
1647	}
1648	if (lang && !forceLang && this.opt["default-locale"][0]) {
1649		lang = this.opt["default-locale"][0];
1650	}
1651	if (this.opt["default-locale"].length === 0) {
1652		if (!lang) {
1653			lang = "en-US";
1654		}
1655		this.opt["default-locale"].push("en-US");
1656	}
1657	if (!lang) {
1658		lang = this.opt["default-locale"][0];
1659	}
1660	langspec = CSL.localeResolve(lang);
1661	this.opt.lang = langspec.best;
1662	this.opt["default-locale"][0] = langspec.best;
1663	this.locale = {};
1664	if (!this.opt["default-locale-sort"]) {
1665		this.opt["default-locale-sort"] = this.opt["default-locale"][0];
1666	}
1667	this.localeConfigure(langspec);
1668	function makeRegExp(lst) {
1669		var lst = lst.slice();
1670		var ret = new RegExp( "((?:[?!:]*\\s+|-|^)(?:" + lst.join("|") + ")(?=[!?:]*\\s+|-|$))" );
1671		return ret;
1672	}
1673	this.locale[this.opt.lang].opts["skip-words-regexp"] = makeRegExp(this.locale[this.opt.lang].opts["skip-words"]);
1674	this.output.adjust = new CSL.Output.Queue.adjust(this.getOpt('punctuation-in-quote'));
1675	this.registry = new CSL.Registry(this);
1676	this.buildTokenLists("citation");
1677	this.buildTokenLists("bibliography");
1678	this.configureTokenLists();
1679	this.disambiguate = new CSL.Disambiguation(this);
1680	this.splice_delimiter = false;
1681	this.fun.dateparser = new CSL.DateParser();
1682	this.fun.flipflopper = new CSL.Util.FlipFlopper(this);
1683	this.setCloseQuotesArray();
1684	this.fun.ordinalizer.init(this);
1685	this.fun.long_ordinalizer.init(this);
1686	this.fun.page_mangler = CSL.Util.PageRangeMangler.getFunction(this, "page");
1687	this.fun.year_mangler = CSL.Util.PageRangeMangler.getFunction(this, "year");
1688	this.setOutputFormat("html");
1689};
1690CSL.Engine.prototype.setCloseQuotesArray = function () {
1691	var ret;
1692	ret = [];
1693	ret.push(this.getTerm("close-quote"));
1694	ret.push(this.getTerm("close-inner-quote"));
1695	ret.push('"');
1696	ret.push("'");
1697	this.opt.close_quotes_array = ret;
1698};
1699CSL.makeBuilder = function (me) {
1700	function enterFunc (node) {
1701		CSL.XmlToToken.call(node, me, CSL.START);
1702	};
1703	function leaveFunc (node) {
1704		CSL.XmlToToken.call(node, me, CSL.END);
1705	};
1706	function singletonFunc (node) {
1707		CSL.XmlToToken.call(node, me, CSL.SINGLETON);
1708	};
1709	function buildStyle (node) {
1710		var starttag, origparent;
1711		if (me.sys.xml.numberofnodes(me.sys.xml.children(node))) {
1712			origparent = node;
1713			enterFunc(origparent);
1714			for (var i=0;i<me.sys.xml.numberofnodes(me.sys.xml.children(origparent));i+=1) {
1715				node = me.sys.xml.children(origparent)[i];
1716				if (me.sys.xml.nodename(node) === null) {
1717					continue;
1718				}
1719				if (me.sys.xml.nodename(node) === "date") {
1720					CSL.Util.fixDateNode.call(me, origparent, i, node)
1721					node = me.sys.xml.children(origparent)[i];
1722				}
1723				buildStyle(node, enterFunc, leaveFunc, singletonFunc);
1724			}
1725			leaveFunc(origparent);
1726		} else {
1727			singletonFunc(node);
1728		}
1729	}
1730	return buildStyle;
1731};
1732CSL.Engine.prototype.buildTokenLists = function (area) {
1733	var builder = CSL.makeBuilder(this);
1734	var area_nodes;
1735	area_nodes = this.sys.xml.getNodesByName(this.cslXml, area);
1736	if (!this.sys.xml.getNodeValue(area_nodes)) {
1737		return;
1738	}
1739	this.build.area = area;
1740	var mynode = area_nodes[0];
1741	builder(mynode);
1742};
1743CSL.Engine.prototype.setStyleAttributes = function () {
1744	var dummy, attr, key, attributes, attrname;
1745	dummy = {};
1746	var cslXml = this.cslXml;
1747	var tagName = this.cslXml.tagName ? ("" + this.cslXml.tagName).toLowerCase() : "";
1748	if (tagName !== 'style' && tagName !== 'cslstyle') {
1749		if (this.cslXml.getElementsByTagName) {
1750			var cslXml = this.cslXml.getElementsByTagName('style')[0];
1751		}
1752	}
1753	dummy.name = this.sys.xml.nodename(cslXml);
1754	attributes = this.sys.xml.attributes(cslXml);
1755	for (attrname in attributes) {
1756		if (attributes.hasOwnProperty(attrname)) {

1757			CSL.Attributes[attrname].call(dummy, this, attributes[attrname]);
1758		}
1759	}
1760};
1761CSL.Engine.prototype.getTerm = function (term, form, plural, gender, mode, forceDefaultLocale) {
1762	if (term && term.match(/[A-Z]/) && term === term.toUpperCase()) {
1763		CSL.debug("Warning: term key is in uppercase form: "+term);
1764		term = term.toLowerCase();
1765	}
1766	var lang;
1767	if (forceDefaultLocale) {
1768		lang = this.opt["default-locale"][0];
1769	} else {
1770		lang = this.opt.lang;
1771	}
1772	var ret = CSL.Engine.getField(CSL.LOOSE, this.locale[lang].terms, term, form, plural, gender);
1773	if (!ret && term === "range-delimiter") {
1774		ret = "\u2013";
1775	}
1776	if (typeof ret === "undefined") {
1777		if (mode === CSL.STRICT) {
1778			throw "Error in getTerm: term \"" + term + "\" does not exist.";
1779		} else if (mode === CSL.TOLERANT) {
1780			ret = "";
1781		}
1782	}
1783	if (ret) {
1784		this.tmp.cite_renders_content = true;
1785	}
1786	return ret;
1787};
1788CSL.Engine.prototype.getDate = function (form, forceDefaultLocale) {
1789	var lang;
1790	if (forceDefaultLocale) {
1791		lang = this.opt["default-locale"];
1792	} else {
1793		lang = this.opt.lang;
1794	}
1795	if (this.locale[lang].dates[form]) {
1796		return this.locale[lang].dates[form];
1797	} else {
1798		return false;
1799	}
1800};
1801CSL.Engine.prototype.getOpt = function (arg) {
1802	if ("undefined" !== typeof this.locale[this.opt.lang].opts[arg]) {
1803		return this.locale[this.opt.lang].opts[arg];
1804	} else {
1805		return false;
1806	}
1807};
1808CSL.Engine.prototype.getVariable = function (Item, varname, form, plural) {
1809	return CSL.Engine.getField(CSL.LOOSE, Item, varname, form, plural);
1810};
1811CSL.Engine.prototype.getDateNum = function (ItemField, partname) {
1812	if ("undefined" === typeof ItemField) {
1813		return 0;
1814	} else {
1815		return ItemField[partname];
1816	}
1817};
1818CSL.Engine.getField = function (mode, hash, term, form, plural, gender) {
1819	var ret, forms, f, pos, len, hashterm;
1820	ret = "";
1821	if ("undefined" === typeof hash[term]) {
1822		if (mode === CSL.STRICT) {
1823			throw "Error in getField: term \"" + term + "\" does not exist.";
1824		} else {
1825			return undefined;
1826		}
1827	}
1828	if (gender && hash[term][gender]) {
1829		hashterm = hash[term][gender];
1830	} else {
1831		hashterm = hash[term];
1832	}
1833	forms = [];
1834	if (form === "symbol") {
1835		forms = ["symbol", "short"];
1836	} else if (form === "verb-short") {
1837		forms = ["verb-short", "verb"];
1838	} else if (form !== "long") {
1839		forms = [form];
1840	}
1841	forms = forms.concat(["long"]);
1842	len = forms.length;
1843	for (pos = 0; pos < len; pos += 1) {
1844		f = forms[pos];
1845		if ("string" === typeof hashterm || "number" === typeof hashterm) {
1846			ret = hashterm;
1847		} else if ("undefined" !== typeof hashterm[f]) {
1848			if ("string" === typeof hashterm[f] || "number" === typeof hashterm[f]) {
1849				ret = hashterm[f];
1850			} else {
1851				if ("number" === typeof plural) {
1852					ret = hashterm[f][plural];
1853				} else {
1854					ret = hashterm[f][0];
1855				}
1856			}
1857			break;
1858		}
1859	}
1860	return ret;
1861};
1862CSL.Engine.prototype.configureTokenLists = function () {
1863	var dateparts_master, area, pos, token, dateparts, part, ppos, pppos, len, llen, lllen;
1864	dateparts_master = ["year", "month", "day"];
1865	len = CSL.AREAS.length;
1866	for (pos = 0; pos < len; pos += 1) {
1867		area = CSL.AREAS[pos];
1868		llen = this[area].tokens.length - 1;
1869		for (ppos = llen; ppos > -1; ppos += -1) {
1870			token = this[area].tokens[ppos];
1871			if ("date" === token.name && CSL.END === token.tokentype) {
1872				dateparts = [];
1873			}
1874			if ("date-part" === token.name && token.strings.name) {
1875				lllen = dateparts_master.length;
1876				for (pppos = 0; pppos < lllen; pppos += 1) {
1877					part = dateparts_master[pppos];
1878					if (part === token.strings.name) {
1879						dateparts.push(token.strings.name);
1880					}
1881				}
1882			}
1883			if ("date" === token.name && CSL.START === token.tokentype) {
1884				dateparts.reverse();
1885				token.dateparts = dateparts;
1886			}
1887			token.next = (ppos + 1);
1888			if (token.name && CSL.Node[token.name].configure) {
1889				CSL.Node[token.name].configure.call(token, this, ppos);
1890			}
1891		}
1892	}
1893	this.version = CSL.version;
1894	return this.state;
1895};
1896CSL.Engine.prototype.retrieveItems = function (ids) {
1897	var ret, pos, len;
1898	ret = [];
1899	for (var i = 0, ilen = ids.length; i < ilen; i += 1) {
1900		ret.push(this.retrieveItem("" + ids[i]));
1901	}
1902	return ret;
1903};
1904CSL.ITERATION = 0;
1905CSL.Engine.prototype.retrieveItem = function (id) {
1906	var Item, m, pos, len, mm;
1907	if (this.opt.development_extensions.normalize_lang_keys_to_lowercase &&
1908		"boolean" === typeof this.opt.development_extensions.normalize_lang_keys_to_lowercase) {
1909		for (var i=0,ilen=this.opt["default-locale"].length; i<ilen; i+=1) {
1910			this.opt["default-locale"][i] = this.opt["default-locale"][i].toLowerCase();
1911		}
1912		for (var i=0,ilen=this.opt["locale-translit"].length; i<ilen; i+=1) {
1913			this.opt["locale-translit"][i] = this.opt["locale-translit"][i].toLowerCase();
1914		}
1915		for (var i=0,ilen=this.opt["locale-translat"].length; i<ilen; i+=1) {
1916			this.opt["locale-translat"][i] = this.opt["locale-translat"][i].toLowerCase();
1917		}
1918		this.opt.development_extensions.normalize_lang_keys_to_lowercase = 100;
1919	}
1920	CSL.ITERATION += 1;
1921	Item = this.sys.retrieveItem("" + id);
1922	if (this.opt.development_extensions.normalize_lang_keys_to_lowercase) {
1923		if (Item.multi) {
1924			if (Item.multi._keys) {
1925				for (var field in Item.multi._keys) {
1926					for (var key in Item.multi._keys[field]) {
1927						if (key !== key.toLowerCase()) {
1928							Item.multi._keys[field][key.toLowerCase()] = Item.multi._keys[field][key];
1929							delete Item.multi._keys[field][key];
1930						}
1931					}
1932				}
1933			}
1934			if (Item.multi.main) {
1935				for (var field in Item.multi.main) {
1936					Item.multi.main[field] = Item.multi.main[field].toLowerCase();
1937				}
1938			}
1939		}
1940		for (var i=0, ilen=CSL.CREATORS.length; i>ilen; i+=1) {
1941			var ctype = CSL.CREATORS[i];
1942			if (Item[ctype] && Item[ctype].multi) {
1943				for (var j=0, jlen=Item[ctype].length; j<jlen; j+=1) {
1944					var creator = Item[ctype][j];
1945					if (creator.multi) {
1946						if (creator.multi._key) {
1947							for (var key in creator.multi._key) {
1948								if (key !== key.toLowerCase()) {
1949									creator.multi._key[key.toLowerCase()] = creator.multi._key[key];
1950									delete creator.multi._key[key];
1951								}
1952							}
1953						}
1954						if (creator.multi.main) {
1955							creator.multi.main = creator.multi.main.toLowerCase();
1956						}
1957					}
1958				}
1959			}
1960		}
1961	}
1962	if (Item.page) {
1963		Item["page-first"] = Item.page;
1964		var num = "" + Item.page;
1965		m = num.split(/\s*(?:&|,|-|\u2013)\s*/);
1966		if (m[0].slice(-1) !== "\\") {
1967			Item["page-first"] = m[0];
1968		}
1969	}
1970	if (this.opt.development_extensions.field_hack && Item.note) {
1971		m = Item.note.match(CSL.NOTE_FIELDS_REGEXP);
1972		if (m) {
1973			var names = {};
1974			for (pos = 0, len = m.length; pos < len; pos += 1) {
1975				mm = m[pos].match(CSL.NOTE_FIELD_REGEXP);
1976				if (!Item[mm[1]] && CSL.DATE_VARIABLES.indexOf(mm[1]) > -1) {
1977					Item[mm[1]] = {raw:mm[2]};
1978				} else if (!Item[mm[1]] && CSL.NAME_VARIABLES.indexOf(mm[1]) > -1) {
1979					if (!Item[mm[1]]) {
1980						Item[mm[1]] = [];
1981					}
1982					var lst = mm[2].split(/\s*\|\|\s*/);
1983					if (lst.length === 1) {
1984						Item[mm[1]].push({family:lst[0],isInstitution:true});
1985					} else if (lst.length === 2) {
1986						Item[mm[1]].push({family:lst[0],given:lst[1]});
1987					}
1988				} else if (!Item[mm[1]] || mm[1] === "type") {
1989					Item[mm[1]] = mm[2].replace(/^\s+/, "").replace(/\s+$/, "");
1990				}
1991				Item.note.replace(CSL.NOTE_FIELD_REGEXP, "");
1992			}
1993		}
1994	}
1995	for (var i = 1, ilen = CSL.DATE_VARIABLES.length; i < ilen; i += 1) {
1996		var dateobj = Item[CSL.DATE_VARIABLES[i]];
1997		if (dateobj) {
1998			if (this.opt.development_extensions.raw_date_parsing) {
1999				if (dateobj.raw) {
2000					dateobj = this.fun.dateparser.parse(dateobj.raw);
2001				}
2002			}
2003			Item[CSL.DATE_VARIABLES[i]] = this.dateParseArray(dateobj);
2004		}
2005	}
2006	if (this.opt.development_extensions.static_statute_locator) {
2007		if (Item.type && ["bill","gazette","legislation","treaty"].indexOf(Item.type) > -1) {
2008			var varname;
2009			var elements = ["type", "title", "jurisdiction", "genre", "volume", "container-title"];
2010			var legislation_id = [];
2011			for (i = 0, ilen = elements.length; i < ilen; i += 1) {
2012				varname = elements[i];
2013				if (Item[varname]) {
2014					legislation_id.push(Item[varname]);
2015				}
2016			}
2017			elements = ["original-date", "issued"];
2018			for (i = 0, elements.length; i < ilen; i += 1) {
2019				varname = elements[i];
2020				if (Item[varname] && Item[varname].year) {
2021					var value = Item[varname].year;
2022					legislation_id.push(value);
2023					break;
2024				}
2025			}
2026			Item.legislation_id = legislation_id.join("::");
2027		}
2028	}
2029	if (!Item["title-short"]) {
2030		Item["title-short"] = Item.shortTitle;
2031	}
2032	if (this.opt.development_extensions.main_title_from_short_title) {
2033		Item["title-main"] = Item.title;
2034		Item["title-sub"] = false;

2035		if (Item.title && Item['title-short']) {
2036			var shortTitle = Item['title-short'];
2037			offset = shortTitle.length;
2038			if (Item.title.slice(0,offset) === shortTitle && Item.title.slice(offset).match(/^\s*:/)) {
2039				Item["title-main"] = Item.title.slice(0,offset).replace(/\s+$/,"");
2040				Item["title-sub"] = Item.title.slice(offset).replace(/^\s*:\s*/,"");
2041				if (this.opt.development_extensions.uppercase_subtitles && Item["title-sub"]) {
2042					var subtitle = Item["title-sub"]
2043					for (var i=0,ilen=subtitle.length;i<ilen;i++) {
2044						if (subtitle.charAt(i).toLowerCase() !== subtitle.charAt(i).toUpperCase()) {
2045							Item["title-sub"] = subtitle.slice(0,i) + subtitle.charAt(i).toUpperCase() + subtitle.slice(i+1);
2046							break
2047						}
2048					}
2049				}
2050				var mainPlusJoinOffset = offset + Item.title.length - Item["title-main"].length - Item["title-sub"].length;
2051				Item.title = Item.title.slice(0,mainPlusJoinOffset) + Item["title-sub"];
2052			}
2053		}
2054	}
2055	var isLegalType = ["legal_case","legislation","gazette","regulation"].indexOf(Item.type) > -1;
2056	if (!isLegalType && Item.title && this.sys.getAbbreviation) {
2057		var noHints = false;
2058		if (!Item.jurisdiction) {
2059			noHints = true;
2060		}
2061		var jurisdiction = this.transform.loadAbbreviation(Item.jurisdiction, "title", Item.title, Item.type, true);
2062		if (this.transform.abbrevs[jurisdiction].title) {
2063			if (this.transform.abbrevs[jurisdiction].title[Item.title]) {
2064				Item["title-short"] = this.transform.abbrevs[jurisdiction].title[Item.title];
2065			}
2066		}
2067	}
2068	Item["container-title-short"] = Item.journalAbbreviation;
2069	if (Item["container-title"] && this.sys.getAbbreviation) {
2070		var jurisdiction = this.transform.loadAbbreviation(Item.jurisdiction, "container-title", Item["container-title"]);
2071		if (this.transform.abbrevs[jurisdiction]["container-title"]) {
2072			if (this.transform.abbrevs[jurisdiction]["container-title"][Item["container-title"]]) {
2073				Item["container-title-short"] = this.transform.abbrevs[jurisdiction]["container-title"][Item["container-title"]];
2074			}
2075		}
2076	}
2077	return Item;
2078};
2079CSL.Engine.prototype.setOpt = function (token, name, value) {
2080	if (token.name === "style" || token.name === "cslstyle") {
2081		this.opt[name] = value;
2082	} else if (["citation", "bibliography"].indexOf(token.name) > -1) {
2083		this[token.name].opt[name] = value;
2084	} else if (["name-form", "name-delimiter", "names-delimiter"].indexOf(name) === -1) {
2085		token.strings[name] = value;
2086	}
2087};
2088CSL.Engine.prototype.fixOpt = function (token, name, localname) {
2089	if (["citation", "bibliography"].indexOf(token.name) > -1) {
2090		if (! this[token.name].opt[name] && "undefined" !== typeof this.opt[name]) {
2091			this[token.name].opt[name] = this.opt[name];
2092		}
2093	}
2094	if ("name" === token.name || "names" === token.name) {
2095		if ("undefined" === typeof token.strings[localname] && "undefined" !== typeof this[this.build.root].opt[name]) {
2096			token.strings[localname] = this[this.build.root].opt[name];
2097		}
2098	}
2099};
2100CSL.Engine.prototype.remapSectionVariable = function (inputList) {
2101	for (var i = 0, ilen = inputList.length; i < ilen; i += 1) {
2102		var Item = inputList[i][0];
2103		var item = inputList[i][1];
2104		var section_label_count = 0;
2105		var later_label = false;
2106		var value = false;
2107		if (["bill","gazette","legislation","treaty"].indexOf(Item.type) > -1) {
2108			item.force_pluralism = 0;
2109			if (!item.label) {
2110				item.label = "page"
2111			}
2112			var loci = ["section","","",""];
2113			var split;
2114			if (this.opt.development_extensions.static_statute_locator && Item.section) {
2115				splt = Item.section.replace(/^\s+/,"").replace(/\s+$/, "").split(/\s+/);
2116				if (CSL.STATUTE_SUBDIV_STRINGS[splt[0]]) {
2117					loci[0] = " " + splt[0] + " ";
2118					loci[1] = splt.slice(1).join(" ");
2119				} else {
2120					loci[0] = " sec. ";
2121					loci[1] = splt.slice(0).join(" ");
2122				}
2123			} else {
2124				if (this.opt.development_extensions.clobber_locator_if_no_statute_section) {
2125					item.locator = undefined;
2126					item.label = undefined;
2127				}
2128			}
2129			if (item.locator) {
2130				var splt = item.locator.replace(/^\s+/,"").replace(/\s+$/, "").split(/\s+/);
2131				if (CSL.STATUTE_SUBDIV_STRINGS[splt[0]]) {
2132					loci[2] = " " + splt[0] + " ";

2133					loci[3] = splt.slice(1).join(" ");
2134				} else if (item.label) {
2135					loci[2] = " " + CSL.STATUTE_SUBDIV_STRINGS_REVERSE[item.label] + " ";
2136					loci[3] = splt.slice(0).join(" ");
2137				} else {
2138					loci[3] = splt.join(" ")
2139				}
2140				if (loci[3] && loci[3].slice(0,1) === "&") {
2141					loci[3] = " " + loci[3];
2142				}
2143			}
2144			if (!loci[2]) {
2145				loci[2] = loci[0];
2146			}
2147			if (loci[3]) {
2148				if (loci[3].match(/^[^0-9a-zA-Z]/)) {
2149					var loclst = loci[3].split(/\s+/);
2150					if (loci[0] === loci[2] && loclst[1] && !CSL.STATUTE_SUBDIV_STRINGS[loclst[1].replace(/\s+/, "").replace(/\s+/, "")]) {
2151						item.force_pluralism = 1;
2152					}
2153					loci[2] = "";
2154				}
2155			} else {
2156				loci[2] = "";
2157			}
2158			if (!loci[1]) {
2159				loci[0] = "";
2160			}
2161			var value = loci.join("");
2162			value = value.replace(/^\s+/,"").replace(/\s+$/, "");
2163			if (value) {
2164				splt = value.split(/\s+/);
2165				if (CSL.STATUTE_SUBDIV_STRINGS[splt[0]]) {
2166					var has_other = false;
2167					for (var j = splt.length - 2; j > 0; j += -2) {
2168						if (splt[j] === splt[0]) {
2169							item.force_pluralism = 1;
2170							splt = splt.slice(0,j).concat(splt.slice(j + 1));
2171						}
2172					}
2173					item.label = CSL.STATUTE_SUBDIV_STRINGS[splt[0]];
2174					item.locator = splt.slice(1).join(" ");
2175					if (item.force_pluralism === 0) {
2176						delete item.force_pluralism;
2177					}
2178				} else {
2179					item.locator = splt.slice(0).join(" ");
2180				}
2181			}
2182		}
2183	}
2184}
2185CSL.Engine.prototype.setNumberLabels = function (Item) {
2186	if (Item.number
2187		&& ["bill", "gazette", "legislation", "treaty"].indexOf(Item.type) > -1
2188		&& this.opt.development_extensions.static_statute_locator
2189		&& !this.tmp.shadow_numbers["number"]) {
2190		this.tmp.shadow_numbers["number"] = {};
2191		this.tmp.shadow_numbers["number"].values = [];
2192		this.tmp.shadow_numbers["number"].plural = 0;
2193		this.tmp.shadow_numbers["number"].numeric = false;
2194		this.tmp.shadow_numbers["number"].label = false;
2195		var value = "" + Item.number;
2196		value = value.replace("\\", "", "g");
2197		var firstword = value.split(/\s/)[0];
2198		var firstlabel = CSL.STATUTE_SUBDIV_STRINGS[firstword];
2199		if (firstlabel) {
2200			var m = value.match(CSL.STATUTE_SUBDIV_GROUPED_REGEX);
2201			var splt = value.split(CSL.STATUTE_SUBDIV_PLAIN_REGEX);
2202			if (splt.length > 1) {
2203				var lst = [];
2204				for (var j=1, jlen=splt.length; j < jlen; j += 1) {
2205					var subdiv = m[j - 1].replace(/^\s*/, "");
2206					lst.push(subdiv.replace("sec.", "Sec.").replace("ch.", "Ch."));
2207					lst.push(splt[j].replace(/\s*$/, "").replace(/^\s*/, ""));
2208				}
2209				value = lst.join(" ");
2210			} else {
2211				value = splt[0];
2212			}
2213			this.tmp.shadow_numbers["number"].values.push(["Blob", value, false]);
2214			this.tmp.shadow_numbers["number"].numeric = false;
2215		} else {
2216			this.tmp.shadow_numbers["number"].values.push(["Blob", value, false]);
2217			this.tmp.shadow_numbers["number"].numeric = true;
2218		}
2219	}
2220}
2221CSL.substituteOne = function (template) {
2222	return function (state, list) {
2223		if (!list) {
2224			return "";
2225		} else {
2226			return template.replace("%%STRING%%", list);
2227		}
2228	};
2229};
2230CSL.substituteTwo = function (template) {
2231	return function (param) {
2232		var template2 = template.replace("%%PARAM%%", param);
2233		return function (state, list) {
2234			if (!list) {
2235				return "";
2236			} else {
2237				return template2.replace("%%STRING%%", list);
2238			}
2239		};
2240	};
2241};
2242CSL.Mode = function (mode) {
2243	var decorations, params, param, func, val, args;
2244	decorations = {};
2245	params = CSL.Output.Formats[mode];
2246	for (param in params) {
2247		if (true) {
2248			if ("@" !== param.slice(0, 1)) {
2249				decorations[param] = params[param];
2250				continue;
2251			}
2252			func = false;
2253			val = params[param];
2254			args = param.split('/');
2255			if (typeof val === "string" && val.indexOf("%%STRING%%") > -1)  {
2256				if (val.indexOf("%%PARAM%%") > -1) {
2257					func = CSL.substituteTwo(val);
2258				} else {
2259					func = CSL.substituteOne(val);
2260				}
2261			} else if (typeof val === "boolean" && !val) {
2262				func = CSL.Output.Formatters.passthrough;
2263			} else if (typeof val === "function") {
2264				func = val;
2265			} else {
2266				throw "CSL.Compiler: Bad " + mode + " config entry for " + param + ": " + val;
2267			}

2268			if (args.length === 1) {
2269				decorations[args[0]] = func;
2270			} else if (args.length === 2) {
2271				if (!decorations[args[0]]) {
2272					decorations[args[0]] = {};
2273				}
2274				decorations[args[0]][args[1]] = func;
2275			}
2276		}
2277	}
2278	return decorations;
2279};
2280CSL.setDecorations = function (state, attributes) {
2281	var ret, key, pos;
2282	ret = [];
2283	for (pos in CSL.FORMAT_KEY_SEQUENCE) {
2284		if (true) {
2285			key = CSL.FORMAT_KEY_SEQUENCE[pos];
2286			if (attributes[key]) {
2287				ret.push([key, attributes[key]]);
2288				delete attributes[key];
2289			}
2290		}
2291	}
2292	return ret;
2293};
2294CSL.Engine.prototype.normalDecorIsOrphan = function (blob, params) {
2295	if (params[1] === "normal") {
2296		var use_param = false;
2297		var all_the_decor;
2298		if (this.tmp.area === "citation") {
2299			all_the_decor = [this.citation.opt.layout_decorations].concat(blob.alldecor);
2300		} else {
2301			all_the_decor = blob.alldecor;
2302		}
2303		for (var k = all_the_decor.length - 1; k > -1; k += -1) {
2304			for (var n = all_the_decor[k].length - 1; n > -1; n += -1) {
2305				if (all_the_decor[k][n][0] === params[0]) {
2306					if (all_the_decor[k][n][1] !== "normal") {
2307						use_param = true;
2308					}
2309				}
2310			}
2311		}
2312		if (!use_param) {
2313			return true;
2314		}
2315	}
2316	return false;
2317};
2318CSL.Engine.prototype.getCitationLabel = function (Item) {
2319	var label = "";
2320	var params = this.getTrigraphParams();
2321	var config = params[0];
2322	var myname = this.getTerm("reference", "short", 0);
2323	if ("undefined" === typeof myname) {
2324		myname = "reference";
2325	}
2326	myname = myname.replace(".", "");
2327	myname = myname.slice(0, 1).toUpperCase() + myname.slice(1);
2328	for (var i = 0, ilen = CSL.CREATORS.length; i < ilen; i += 1) {
2329		var n = CSL.CREATORS[i];
2330		if (Item[n]) {
2331			var names = Item[n];
2332			if (names.length > params.length) {
2333				config = params[params.length - 1];
2334			} else {
2335				config = params[names.length - 1];
2336			}
2337			for (var j = 0, jlen = names.length; j < jlen; j += 1) {
2338				if (j === config.authors.length) {
2339					break;
2340				}
2341				var res = this.nameOutput.getName(names[j], "locale-translit", true);
2342				var name = res.name;
2343				if (name && name.family) {
2344					myname = name.family;
2345					myname = myname.replace(/^([ \'\u2019a-z]+\s+)/, "");
2346				} else if (name && name.literal) {
2347					myname = name.literal;
2348				}
2349				var m = myname.toLowerCase().match(/^(a\s+|the\s+|an\s+)/);
2350				if (m) {
2351					myname = myname.slice(m[1].length);
2352				}
2353				myname = myname.replace(CSL.ROMANESQUE_NOT_REGEXP, "", "g");
2354				if (!myname) {
2355					break;
2356				}
2357				myname = myname.slice(0, config.authors[j]);
2358				if (myname.length > 1) {
2359					myname = myname.slice(0, 1).toUpperCase() + myname.slice(1).toLowerCase();
2360				} else if (myname.length === 1) {
2361					myname = myname.toUpperCase();
2362				}
2363				label += myname;
2364			}
2365			break;
2366		}
2367	}
2368	var year = "0000";
2369	if (Item.issued) {
2370		if (Item.issued.year) {
2371			year = "" + Item.issued.year;
2372		}
2373	}
2374	year = year.slice((config.year * -1));
2375	label = label + year;
2376	return label;
2377};
2378CSL.Engine.prototype.getTrigraphParams = function () {
2379	var params = [];
2380	var ilst = this.opt.trigraph.split(":");
2381	if (!this.opt.trigraph || this.opt.trigraph.slice(0,1) !== "A") {
2382		throw "Bad trigraph definition: "+this.opt.trigraph;
2383	}
2384	for (var i = 0, ilen = ilst.length; i < ilen; i += 1) {
2385		var str = ilst[i];
2386		var config = {authors:[], year:0};
2387		for (var j = 0, jlen = str.length; j < jlen; j += 1) {
2388			switch (str.slice(j,j+1)) {
2389			case "A":
2390				config.authors.push(1);
2391				break;
2392			case "a":
2393				config.authors[config.authors.length - 1] += 1;
2394				break;
2395			case "0":
2396				config.year += 1;
2397				break;
2398			default:
2399				throw "Invalid character in trigraph definition: "+this.opt.trigraph;
2400			}
2401		}
2402		params.push(config);
2403	}
2404	return params;
2405};
2406CSL.Engine.prototype.setOutputFormat = function (mode) {
2407	this.opt.mode = mode;
2408	this.fun.decorate = CSL.Mode(mode);
2409	if (!this.output[mode]) {
2410		this.output[mode] = {};
2411		this.output[mode].tmp = {};
2412	}
2413};
2414CSL.Engine.prototype.getSortFunc = function () {
2415	return function (a,b) {
2416		a = a.split("-");
2417		b = b.split("-");
2418		if (a.length < b.length) {
2419			return 1
2420		} else if (a.length > b.length) {
2421			return -1
2422		} else {
2423			a = a.slice(-1)[0];
2424			b = b.slice(-1)[0];
2425			if (a.length < b.length) {
2426				return 1;
2427			} else if (a.length > b.length) {
2428				return -1;
2429			} else {
2430				return 0;
2431			}
2432		}
2433	};
2434};
2435CSL.Engine.prototype.setLangTagsForCslSort = function (tags) {
2436	var i, ilen;
2437	if (tags) {
2438		this.opt['locale-sort'] = [];
2439		for (i = 0, ilen = tags.length; i < ilen; i += 1) {
2440			this.opt['locale-sort'].push(tags[i]);
2441		}
2442	}
2443	this.opt['locale-sort'].sort(this.getSortFunc());
2444};
2445CSL.Engine.prototype.setLangTagsForCslTransliteration = function (tags) {
2446	var i, ilen;
2447	this.opt['locale-translit'] = [];
2448	if (tags) {
2449		for (i = 0, ilen = tags.length; i < ilen; i += 1) {
2450			this.opt['locale-translit'].push(tags[i]);
2451		}
2452	}
2453	this.opt['locale-translit'].sort(this.getSortFunc());
2454};
2455CSL.Engine.prototype.setLangTagsForCslTranslation = function (tags) {
2456	var i, ilen;
2457	this.opt['locale-translat'] = [];
2458	if (tags) {
2459		for (i = 0, ilen = tags.length; i < ilen; i += 1) {
2460			this.opt['locale-translat'].push(tags[i]);
2461		}
2462	}
2463	this.opt['locale-translat'].sort(this.getSortFunc());
2464};
2465CSL.Engine.prototype.setLangPrefsForCites = function (obj, conv) {
2466	var opt = this.opt['cite-lang-prefs'];
2467	if (!conv) {
2468		conv = function (key) {
2469			return key.toLowerCase();
2470		};
2471	}
2472	var segments = ['Persons', 'Institutions', 'Titles', 'Journals', 'Publishers', 'Places'];
2473	for (var i = 0, ilen = segments.length; i < ilen; i += 1) {
2474		var clientSegment = conv(segments[i]);
2475		var citeprocSegment = segments[i].toLowerCase();
2476		if (!obj[clientSegment]) {
2477			continue;
2478		}
2479		var supplements = [];
2480		while (obj[clientSegment].length > 1) {
2481			supplements.push(obj[clientSegment].pop());
2482		}
2483		var sortval = {orig:1,translit:2,translat:3};
2484		if (supplements.length === 2 && sortval[supplements[0]] < sortval[supplements[1]]) {
2485			supplements.reverse();
2486		}
2487		while (supplements.length) {
2488			obj[clientSegment].push(supplements.pop());
2489		}
2490		var lst = opt[citeprocSegment];
2491		while (lst.length) {
2492			lst.pop();
2493		}
2494		for (var j = 0, jlen = obj[clientSegment].length; j < jlen; j += 1) {
2495			lst.push(obj[clientSegment][j]);
2496		}
2497	}
2498};
2499CSL.Engine.prototype.setLangPrefsForCiteAffixes = function (affixList) {
2500	if (affixList && affixList.length === 48) {
2501		var affixes = this.opt.citeAffixes;
2502		var count = 0;
2503		var settings = ["persons", "institutions", "titles", "journals", "publishers", "places"];
2504		var forms = ["translit", "orig", "translit", "translat"];
2505		var value;
2506		for (var i = 0, ilen = settings.length; i < ilen; i += 1) {
2507			for (var j = 0, jlen = forms.length; j < jlen; j += 1) {
2508				value = "";
2509				if ((count % 8) === 4) {
2510					if (!affixes[settings[i]]["locale-"+forms[j]].prefix
2511						&& !affixes[settings[i]]["locale-"+forms[j]].suffix) {
2512						value = affixList[count] ? affixList[count] : "";
2513						affixes[settings[i]]["locale-" + forms[j]].prefix = value;
2514						value = affixList[count] ? affixList[count + 1] : "";
2515						affixes[settings[i]]["locale-" + forms[j]].suffix = value;
2516					}
2517				} else {
2518					value = affixList[count] ? affixList[count] : "";
2519					affixes[settings[i]]["locale-" + forms[j]].prefix = value;
2520					value = affixList[count] ? affixList[count + 1] : "";
2521					affixes[settings[i]]["locale-" + forms[j]].suffix = value;
2522				}
2523				count += 2;
2524			}
2525		}
2526		this.opt.citeAffixes = affixes;
2527	}
2528};
2529CSL.Engine.prototype.setAutoVietnameseNamesOption = function (arg) {
2530	if (arg) {
2531		this.opt["auto-vietnamese-names"] = true;
2532	} else {
2533		this.opt["auto-vietnamese-names"] = false;

2534	}
2535};
2536CSL.Engine.prototype.setAbbreviations = function (arg) {
2537	if (this.sys.setAbbreviations) {
2538		this.sys.setAbbreviations(arg);
2539	}
2540};
2541CSL.Engine.prototype.setSuppressTrailingPunctuation = function (arg) {
2542	this.citation.opt.suppressTrailingPunctuation = !!arg;
2543};
2544CSL.Output = {};
2545CSL.Output.Queue = function (state) {
2546	this.levelname = ["top"];
2547	this.state = state;
2548	this.queue = [];
2549	this.empty = new CSL.Token("empty");
2550	var tokenstore = {};
2551	tokenstore.empty = this.empty;
2552	this.formats = new CSL.Stack(tokenstore);
2553	this.current = new CSL.Stack(this.queue);
2554};
2555CSL.Output.Queue.prototype.pop = function () {
2556	var drip = this.current.value();
2557	if (drip.length) {
2558		return drip.pop();
2559	} else {
2560		return drip.blobs.pop();
2561	}
2562};
2563CSL.Output.Queue.prototype.getToken = function (name) {
2564	var ret = this.formats.value()[name];
2565	return ret;
2566};
2567CSL.Output.Queue.prototype.mergeTokenStrings = function (base, modifier) {
2568	var base_token, modifier_token, ret, key;
2569	base_token = this.formats.value()[base];
2570	modifier_token = this.formats.value()[modifier];
2571	ret = base_token;
2572	if (modifier_token) {
2573		if (!base_token) {
2574			base_token = new CSL.Token(base, CSL.SINGLETON);
2575			base_token.decorations = [];
2576		}
2577		ret = new CSL.Token(base, CSL.SINGLETON);
2578		key = "";
2579		for (key in base_token.strings) {
2580			if (base_token.strings.hasOwnProperty(key)) {
2581				ret.strings[key] = base_token.strings[key];
2582			}
2583		}
2584		for (key in modifier_token.strings) {
2585			if (modifier_token.strings.hasOwnProperty(key)) {
2586				ret.strings[key] = modifier_token.strings[key];
2587			}
2588		}
2589		ret.decorations = base_token.decorations.concat(modifier_token.decorations);
2590	}
2591	return ret;
2592};
2593CSL.Output.Queue.prototype.addToken = function (name, modifier, token) {
2594	var newtok, attr;
2595	newtok = new CSL.Token("output");
2596	if ("string" === typeof token) {
2597		token = this.formats.value()[token];
2598	}
2599	if (token && token.strings) {
2600		for (attr in token.strings) {
2601			if (token.strings.hasOwnProperty(attr)) {
2602				newtok.strings[attr] = token.strings[attr];
2603			}
2604		}
2605		newtok.decorations = token.decorations;
2606	}
2607	if ("string" === typeof modifier) {
2608		newtok.strings.delimiter = modifier;
2609	}
2610	this.formats.value()[name] = newtok;
2611};
2612CSL.Output.Queue.prototype.pushFormats = function (tokenstore) {
2613	if (!tokenstore) {
2614		tokenstore = {};
2615	}
2616	tokenstore.empty = this.empty;
2617	this.formats.push(tokenstore);
2618};
2619CSL.Output.Queue.prototype.popFormats = function (tokenstore) {
2620	this.formats.pop();
2621};
2622CSL.Output.Queue.prototype.startTag = function (name, token) {
2623	var tokenstore = {};
2624	if (this.state.tmp["doing-macro-with-date"] && this.state.tmp.extension) {
2625		token = this.empty;
2626		name = "empty";
2627	}
2628	tokenstore[name] = token;
2629	this.pushFormats(tokenstore);
2630	this.openLevel(name);
2631};
2632CSL.Output.Queue.prototype.endTag = function (name) {
2633	this.closeLevel();
2634	this.popFormats();
2635};
2636CSL.Output.Queue.prototype.openLevel = function (token, ephemeral) {
2637	var blob, curr, x, has_ephemeral;
2638	if ("object" === typeof token) {
2639		blob = new CSL.Blob(undefined, token);
2640	} else if ("undefined" === typeof token) {
2641		blob = new CSL.Blob(undefined, this.formats.value().empty, "empty");
2642	} else {
2643		if (!this.formats.value() || !this.formats.value()[token]) {
2644			throw "CSL processor error: call to nonexistent format token \"" + token + "\"";
2645		}
2646		blob = new CSL.Blob(undefined, this.formats.value()[token], token);
2647	}
2648	if (this.nestedBraces) {
2649		blob.strings.prefix = blob.strings.prefix.replace(this.nestedBraces[0][0], this.nestedBraces[0][1]);
2650		blob.strings.prefix = blob.strings.prefix.replace(this.nestedBraces[1][0], this.nestedBraces[1][1]);
2651		blob.strings.suffix = blob.strings.suffix.replace(this.nestedBraces[0][0], this.nestedBraces[0][1]);
2652		blob.strings.suffix = blob.strings.suffix.replace(this.nestedBraces[1][0], this.nestedBraces[1][1]);
2653	}
2654	curr = this.current.value();
2655	curr.push(blob);
2656	this.current.push(blob);
2657};
2658CSL.Output.Queue.prototype.closeLevel = function (name) {
2659	if (name && name !== this.current.value().levelname) {
2660		CSL.error("Level mismatch error:  wanted " + name + " but found " + this.current.value().levelname);
2661	}
2662	this.current.pop();
2663};
2664CSL.Output.Queue.prototype.append = function (str, tokname, notSerious, ignorePredecessor, noStripPeriods) {
2665	var token, blob, curr;
2666	var useblob = true;
2667	if (notSerious) {
2668		ignorePredecessor = true;
2669	}
2670	if (this.state.tmp["doing-macro-with-date"] && !notSerious) {
2671		if (tokname !== "macro-with-date") {
2672			return false;