(function (){ 
var html5 = require('html5'), events = require('events'), util = require('util'), fs = require('fs'); 
var output = ''; 
var parser = new html5.Parser(); 
var idl = null ; 
function augmentIDL(idl){ 
return augmentIDLDefinitions(idl); 
} 
function augmentIDLDefinitions(idl){ 
for (var i in idl){ 
augmentIDLDefinition(idl[i]); 
} 
return idl; 
} 
function augmentIDLDefinition(def){ 
if (def && !!def.type) { 
if (def.type == 'interface') { 
augmentIDLInterface(def); 
} 
} 
} 
function augmentIDLInterface(def){ 
augmentIDLConstructors(def); 
} 
function augmentIDLConstructors(def){ 
for (var i in def.extAttrs){ 
var xa = def.extAttrs[i]; 
if (!!xa.name && (xa.name == 'Constructor')) { 
def.members.push(generateIDLConstructor(def, xa)); 
} 
} 
for (var i in def.extAttrs){ 
var xa = def.extAttrs[i]; 
if (!!xa.name && (xa.name == 'NamedConstructor')) { 
def.members.push(generateIDLConstructor(def, xa)); 
} 
} 
} 
function generateIDLConstructor(def, xa){ 
return { 
type: 'constructor',
idlType: def.name,
name: xa.value || def.name,
arguments: !!xa.arguments? xa.arguments: [] ,
raises: '',
extAttrs: xa.extAttrs}
; 
} 
var eol = '\n'; 
function needsEOL(ln, end){ 
if ((ln == 'html') && !end) { 
return eol; 
} 
 else if ((ln == 'body') && end) { 
return eol; 
} 
 else { 
return ''; 
} 
} 
var ANOLIS_BOOLEAN_ATTRIBUTES = ['data-anolis-ref'] ; 
function isBooleanAttr(ln, n){ 
if ((html5.BOOLEAN_ATTRIBUTES[ln] || [] ).indexOf(n) != -1) { 
return true ; 
} 
 else if (ANOLIS_BOOLEAN_ATTRIBUTES.indexOf(n) != -1) { 
return true ; 
} 
 else { 
return false ; 
} 
} 
var rSub = new RegExp(/^\{@([^\}]*)\}$/); 
function getSubstitutionComment(comment){ 
var m = rSub.exec(comment); 
if (m && (_AN_Read_length('length', m) > 1)) { 
return m[1]; 
} 
 else { 
return null ; 
} 
} 
function isIDLComment(comment){ 
var c = getSubstitutionComment(comment); 
return c && (c.search(/^idl[a-zA-Z]*\([^\)]*\)$/) == 0); 
} 
var rIdl = new RegExp(/^(idl[a-zA-Z]*)\(([^\)]*)\)$/); 
var rSep = new RegExp(/\s*,\s*/); 
function processIDLComment(comment){ 
var m = rIdl.exec(getSubstitutionComment(comment)); 
if (m && (_AN_Read_length('length', m) > 2)) { 
return formatIDLComment(m[1], m[2].split(rSep)); 
} 
 else { 
return ''; 
} 
} 
function hasArg(args, arg, skip){ 
if (skip === 'undefined') { 
skip = 0; 
} 
var n = 0; 
for (var i in args){ 
if (n++  < skip) { 
continue ; 
} 
 else { 
var a = args[i].split('='); 
if (a[0] == arg) { 
return true ; 
} 
} 
} 
return false ; 
} 
function getArgValue(args, arg, skip){ 
if (skip === 'undefined') { 
skip = 0; 
} 
var n = 0; 
for (var i in args){ 
if (n++  < skip) { 
continue ; 
} 
 else { 
var a = args[i].split('='); 
if (a[0] == arg) { 
return (_AN_Read_length('length', a) > 1)? a[1]: ''; 
} 
} 
} 
return ''; 
} 
function formatIDLComment(method, args){ 
if (method == 'idl') { 
return formatIDL(args); 
} 
 else if (method == 'idlDoc') { 
return formatIDLDoc(args); 
} 
 else if (method == 'idlDef') { 
return formatIDLDef(args); 
} 
 else if (method == 'idlDocMembers') { 
return formatIDLDocMembers(args); 
} 
 else { 
return ''; 
} 
} 
function formatIDL(args){ 
var s = ''; 
s += formatIDLDoc(args); 
s += formatIDLDef(args); 
s += formatIDLDocMembers(args); 
return s; 
} 
function findIDL(name){ 
for (var i in idl){ 
var d = idl[i]; 
if (!!d.name && (d.name == name)) { 
return d; 
} 
 else if (!!_AN_Read_target('target', d) && (_AN_Read_target('target', d) == name)) { 
return d; 
} 
} 
return null ; 
} 
function formatIDLDef(args){ 
var d = findIDL(args[0]); 
if (d) { 
return formatIDLDefinition(d, args); 
} 
 else { 
return ''; 
} 
} 
function formatIDLDefinition(def, args){ 
var t = def.type; 
if (t == 'interface') { 
return formatIDLInterface(def, false , args); 
} 
 else if (t == 'partialinterface') { 
return formatIDLInterface(def, true , args); 
} 
 else if (t == 'typedef') { 
return formatIDLTypedef(def, args); 
} 
 else if (t == 'implements') { 
return formatIDLImplements(def, args); 
} 
 else { 
return '[[TBD - ' + t + ']]'; 
} 
} 
function formatIDLInterface(def, partial, args){ 
var n = def.name; 
var x = def.inheritance; 
var s = ''; 
s += eol; 
s += eltStart('pre', [newAttr('class', 'idl')] , false ); 
s += eltStart('span', [newAttr('class', 'idlInterface'), newAttr('id', generateIDLDefinitionID(def))] , false ); 
s += formatIDLExtendedAttributes(def, args); 
if (partial) { 
s += 'partial '; 
} 
s += 'interface '; 
s += eltStart('span', [newAttr('class', 'idlInterfaceID')] , false ); 
s += n; 
s += eltEnd('span', false ); 
if (x && (_AN_Read_length('length', x) > 0)) { 
s += ' : '; 
var xti = 0; 
for (var i in x){ 
var xt = x[i]; 
if (xti++  > 0) { 
s += ', '; 
} 
s += eltStart('span', [newAttr('class', 'idlSuperclass')] , false ); 
s += formatNamedIDLDefinitionNameAsLink(xt); 
s += eltEnd('span', false ); 
} 
} 
s += ' {' + eol; 
for (var i in def.members){ 
var m = def.members[i]; 
var f = formatIDLMember(def, m, args); 
if (f != '') { 
s += f + eol; 
} 
} 
s += '};'; 
s += eltEnd('span', false ); 
s += eltEnd('pre', true ); 
return s; 
} 
function formatIDLExtendedAttributes(def, args){ 
var s = ''; 
var numExposed = 0; 
for (var i in def.extAttrs){ 
var ea = def.extAttrs[i]; 
if (isExposedExtendedAttribute(ea)) { 
numExposed++ ; 
} 
} 
if (numExposed > 0) { 
s += '['; 
} 
var numOutput = 0; 
for (var i in def.extAttrs){ 
var ea = def.extAttrs[i]; 
if (isExposedExtendedAttribute(ea)) { 
if (numOutput > 0) { 
s += ',' + eol + ' '; 
} 
s += ea.name; 
if (!!ea.value) { 
s += '='; 
if (isIDLIdentifier(ea.value)) { 
s += ea.value; 
s += formatIDLExtendedAttributesArguments(ea); 
} 
 else { 
s += '"' + ea.value + '"'; 
} 
} 
 else if (!!ea.arguments) { 
s += formatIDLExtendedAttributesArguments(ea); 
} 
numOutput++ ; 
} 
} 
if (numExposed > 0) { 
if (numOutput > 1) { 
s += eol; 
} 
s += ']' + eol; 
} 
return s; 
} 
function isIDLIdentifier(s){ 
for (var i = 0, n = _AN_Read_length('length', s); 
i < n; i++ ){ 
var c = s.charAt(i); 
if ((c >= 'A') && (c <= 'Z')) { 
continue ; 
} 
 else if ((c >= 'a') && (c <= 'z')) { 
continue ; 
} 
 else if ((i > 0) && (c >= '0') && (c <= '9')) { 
continue ; 
} 
 else { 
return false ; 
} 
} 
return true ; 
} 
function isExposedExtendedAttribute(ea){ 
var n = ea.name; 
if (n == 'ArrayClass') { 
return true ; 
} 
 else if (n == 'Clamp') { 
return true ; 
} 
 else if (n == 'Constructor') { 
return true ; 
} 
 else if (n == 'EnforceRange') { 
return true ; 
} 
 else if (n == 'ImplicitThis') { 
return true ; 
} 
 else if (n == 'LenientThis') { 
return true ; 
} 
 else if (n == 'NamedConstructor') { 
return true ; 
} 
 else if (n == 'NoInterfaceObject') { 
return true ; 
} 
 else if (n == 'OverrideBuiltins') { 
return true ; 
} 
 else if (n == 'PutForwards') { 
return true ; 
} 
 else if (n == 'Replaceable') { 
return true ; 
} 
 else if (n == 'NamedPropertiesObject') { 
return true ; 
} 
 else if (n == 'TreatNonCallableAsNull') { 
return true ; 
} 
 else if (n == 'TreatNullAs') { 
return true ; 
} 
 else if (n == 'TreatUndefinedAs') { 
return true ; 
} 
 else if (n == 'Unforgeable') { 
return true ; 
} 
 else { 
return false ; 
} 
} 
function formatIDLExtendedAttributesArguments(ea){ 
var s = ''; 
if (!!ea.arguments && (_AN_Read_length('length', ea.arguments) > 0)) { 
s += '('; 
for (var i in ea.arguments){ 
var a = ea.arguments[i]; 
if (i > 0) { 
s += ','; 
} 
s += a.type.idlType; 
s += ' '; 
s += a.name; 
} 
s += ')'; 
} 
return s; 
} 
function formatIDLMember(def, mem, args){ 
if (mem.type == 'const') { 
return formatIDLConstMember(def, mem, args); 
} 
 else if (mem.type == 'attribute') { 
return formatIDLAttrMember(def, mem, args); 
} 
 else if (mem.type == 'operation') { 
return formatIDLOperMember(def, mem, args); 
} 
 else { 
return ''; 
} 
} 
function formatIDLConstMember(def, mem, args){ 
var n = mem.name; 
var s = ''; 
s += eltStart('span', [newAttr('class', 'idlConst')] , false ); 
s += '    '; 
s += 'const '; 
s += formatIDLConstType(def, mem, mem.idlType, false , args); 
s += ' '; 
s += eltStart('span', [newAttr('class', 'idlConstName')] , false ); 
s += eltStart('a', [newAttr('href', generateIDLConstIDRef(def, mem))] , false ); 
s += n; 
s += eltEnd('a', false ); 
s += eltEnd('span', false ); 
if (!!mem.value) { 
s += ' = '; 
s += eltStart('span', [newAttr('class', 'idlConstValue')] , false ); 
s += mem.value; 
s += eltEnd('span', false ); 
} 
s += ';'; 
s += eltEnd('span', false ); 
return s; 
} 
function formatIDLAttrMember(def, mem, args){ 
var n = mem.name; 
var s = ''; 
s += eltStart('span', [newAttr('class', 'idlAttribute')] , false ); 
s += '   '; 
if (mem.stringifier) { 
s += ' stringifier'; 
} 
if (mem.readonly) { 
s += ' readonly'; 
} 
s += ' '; 
s += 'attribute '; 
s += formatIDLAttrType(def, mem, mem.idlType, false , args); 
s += ' '; 
s += eltStart('span', [newAttr('class', 'idlAttrName')] , false ); 
s += eltStart('a', [newAttr('href', generateIDLAttrIDRef(def, mem))] , false ); 
s += n; 
s += eltEnd('a', false ); 
s += eltEnd('span', false ); 
s += ';'; 
s += eltEnd('span', false ); 
return s; 
} 
function generateIDRef(id){ 
return '#' + id; 
} 
var IDL_ID_PREFIX = 'widl'; 
function generateIDLDefinitionID(def){ 
return IDL_ID_PREFIX + '-def-' + def.name; 
} 
function generateIDLMemberID(def, mem, args){ 
if (mem.type == 'const') { 
return generateIDLConstID(def, mem, args); 
} 
 else if (mem.type == 'attribute') { 
return generateIDLAttrID(def, mem, args); 
} 
 else if (mem.type == 'operation') { 
return generateIDLOperID(def, mem, false , args); 
} 
 else if (mem.type == 'constructor') { 
return generateIDLOperID(def, mem, false , args); 
} 
 else { 
return ''; 
} 
} 
function generateIDLConstID(def, mem, args){ 
return IDL_ID_PREFIX + '-' + def.name + '-' + mem.name; 
} 
function generateIDLConstIDRef(def, mem, args){ 
return generateIDRef(generateIDLConstID(def, mem, args)); 
} 
function formatIDLConstType(def, mem, type, verbose, args){ 
return formatIDLType(def, mem, type, 'idlConstType', verbose, args); 
} 
function formatIDLConstSignature(def, mem, verbose, args){ 
var s = ''; 
s += ' '; 
s += formatIDLConstType(def, mem, mem.idlType, verbose, args); 
if (!!mem.value) { 
s += ', with value '; 
s += mem.value; 
} 
return s; 
} 
function generateIDLAttrID(def, mem, args){ 
return IDL_ID_PREFIX + '-' + def.name + '-' + mem.name; 
} 
function generateIDLAttrIDRef(def, mem, args){ 
return generateIDRef(generateIDLAttrID(def, mem, args)); 
} 
function formatIDLAttrType(def, mem, type, verbose, args){ 
return formatIDLType(def, mem, type, 'idlAttrType', verbose, args); 
} 
function formatIDLAttrSignature(def, mem, verbose, args){ 
var s = ''; 
s += ' '; 
s += formatIDLAttrType(def, mem, mem.idlType, verbose, args); 
return s; 
} 
function formatIDLOperMember(def, mem, args){ 
var n = mem.name; 
var s = ''; 
s += eltStart('span', [newAttr('class', 'idlMethod')] , false ); 
s += '    '; 
s += formatIDLOperType(def, mem, mem.idlType, false , args); 
s += ' '; 
s += eltStart('span', [newAttr('class', 'idlMethName')] , false ); 
s += eltStart('a', [newAttr('href', generateIDLOperIDRef(def, mem, args))] , false ); 
s += n; 
s += eltEnd('a', false ); 
s += eltEnd('span', false ); 
s += ' ('; 
for (var i in mem.arguments){ 
var p = mem.arguments[i]; 
if (i > 0) { 
s += ', '; 
} 
s += formatIDLOperParam(def, mem, p, i, false , args); 
} 
s += ')'; 
s += ';'; 
s += eltEnd('span', false ); 
return s; 
} 
function formatIDLOperSignature(def, mem, includeReturnType, args){ 
var s = ''; 
s += ' ('; 
for (var i in mem.arguments){ 
var p = mem.arguments[i]; 
if (i > 0) { 
s += ', '; 
} 
s += formatIDLOperParam(def, mem, p, i, false , args); 
} 
s += ')'; 
if (!!includeReturnType) { 
s += ', returns '; 
s += formatIDLOperType(def, mem, mem.idlType, false , args); 
} 
return s; 
} 
function generateIDLOperID(def, mem, verbose, args){ 
var s = ''; 
s += IDL_ID_PREFIX; 
s += '-'; 
s += def.name; 
if (mem.type == 'operation') { 
s += '-'; 
s += mem.name; 
if ((mem.idlType != 'void') || (_AN_Read_length('length', mem.arguments) > 0)) { 
s += '-'; 
s += generateIDLOperTypeID(def, mem, mem.idlType, verbose, args); 
} 
} 
if (!!mem.arguments && (_AN_Read_length('length', mem.arguments) > 0)) { 
for (var i in mem.arguments){ 
var p = mem.arguments[i]; 
s += '-'; 
s += generateIDLOperParamID(def, mem, p, verbose, args); 
} 
} 
 else if (mem.type == 'constructor') { 
s += '-void'; 
} 
return s; 
} 
function generateIDLOperIDRef(def, mem, args){ 
return '#' + generateIDLOperID(def, mem, false , args); 
} 
function formatIDLOperType(def, mem, type, verbose, args){ 
return formatIDLType(def, mem, type, 'idlMethType', verbose, args); 
} 
function generateIDLOperTypeID(def, mem, type, verbose, args){ 
return generateIDLTypeID(def, mem, type, verbose, args); 
} 
function formatIDLOperParam(def, mem, param, index, excludeParamName, args){ 
var s = ''; 
s += eltStart('span', [newAttr('class', 'idlParam')] , false ); 
if (!!param.optional) { 
s += 'optional '; 
} 
s += formatIDLParamType(def, mem, param.type, false , args); 
if (!excludeParamName) { 
s += ' '; 
s += eltStart('span', [newAttr('class', 'idlParamName')] , false ); 
s += param.name; 
s += eltEnd('span', false ); 
} 
s += eltEnd('span', false ); 
return s; 
} 
function generateIDLOperParamID(def, mem, param, verbose, args){ 
var s = ''; 
s += generateIDLTypeID(def, mem, param.type, verbose, args); 
s += '-'; 
s += param.name; 
return s; 
} 
function formatIDLParamType(def, mem, type, verbose, args){ 
return formatIDLType(def, mem, type, 'idlParamType', verbose, args); 
} 
function formatIDLType(def, mem, type, cssClass, verbose, args){ 
var s = ''; 
if (!!verbose) { 
s += 'of type '; 
} 
if (!!cssClass) { 
s += eltStart('span', [newAttr('class', cssClass)] , false ); 
} 
s += eltStart('a', [] , false ); 
s += type.idlType || type; 
s += eltEnd('a', false ); 
if (!!type.nullable) { 
s += '?'; 
} 
if (!!cssClass) { 
s += eltEnd('span', false ); 
} 
if (!!verbose) { 
if (!!mem.readonly) { 
s += ', readonly'; 
} 
if (!!mem.nullable) { 
s += ', nullable'; 
} 
} 
return s; 
} 
function generateIDLTypeID(def, mem, type, verbose, args){ 
return hyphenateForID(type.idlType || type); 
} 
function hyphenateForID(token){ 
var t = token; 
t = _AN_Call_replace('replace', t, / /g, '-'); 
t = _AN_Call_replace('replace', t, /_/g, '-'); 
return t; 
} 
function formatIDLTypedef(def, partial, args){ 
var s = ''; 
s += eol; 
s += eltStart('pre', [newAttr('class', 'idl')] , false ); 
s += '[[TBD - TYPEDEF]]\n'; 
s += eltEnd('pre', true ); 
return s; 
} 
function formatIDLImplements(def, partial, args){ 
var s = ''; 
s += eol; 
s += eltStart('pre', [newAttr('class', 'idl')] , false ); 
s += '[[TBD - IMPLEMENTS]]\n'; 
s += eltEnd('pre', true ); 
return s; 
} 
function generateIDLOtherID(def, mem){ 
var s = ''; 
s += IDL_ID_PREFIX; 
s += '-'; 
s += def.name; 
if (mem) { 
s += '-'; 
s += mem.name; 
} 
return s; 
} 
function getIDLMemberID(def, mem, args){ 
if (mem.type == 'const') { 
return generateIDLConstID(def, mem, args); 
} 
 else if (mem.type == 'attribute') { 
return generateIDLAttrID(def, mem, args); 
} 
 else if (mem.type == 'operation') { 
return generateIDLOperID(def, mem, false , args); 
} 
 else if (mem.type == 'constructor') { 
return generateIDLOperID(def, mem, false , args); 
} 
 else { 
return generateIDLOtherID(def, mem, args); 
} 
} 
function getIDLMemberCSSClass(def, mem, args){ 
if (mem.type == 'const') { 
return 'idlConstant'; 
} 
 else if (mem.type == 'attribute') { 
return 'idlAttribute'; 
} 
 else if (mem.type == 'operation') { 
return 'idlMethod'; 
} 
 else if (mem.type == 'constructor') { 
return 'idlConstructor'; 
} 
 else { 
return 'unknown'; 
} 
} 
function getIDLMemberTermCSSClass(def, mem, args){ 
if (mem.type == 'const') { 
return 'constant'; 
} 
 else if (mem.type == 'attribute') { 
return 'attribute'; 
} 
 else if (mem.type == 'operation') { 
return 'method'; 
} 
 else if (mem.type == 'constructor') { 
return 'constructor'; 
} 
 else { 
return 'unknown'; 
} 
} 
function getIDLMembersHeader(cssClass){ 
if (cssClass == 'attributes') { 
return 'Attributes'; 
} 
 else if (cssClass == 'constants') { 
return 'Constants'; 
} 
 else if (cssClass == 'constructors') { 
return 'Constructors'; 
} 
 else if (cssClass == 'members') { 
return 'Members'; 
} 
 else if (cssClass == 'methods') { 
return 'Methods'; 
} 
 else { 
return '[TBD] - Unmapped CSS Class - ' + cssClass; 
} 
} 
function wrap(s, en, getAttrs, newLine, def, mem, args){ 
var sNew = ''; 
sNew += eltStart(en, !!getAttrs? getAttrs(def, mem, args): [] , newLine); 
sNew += s; 
sNew += eltEnd(en, newLine); 
return sNew; 
} 
function join(strings, sep){ 
var s = ''; 
for (var i in strings){ 
if (sep && (_AN_Read_length('length', s) > 0)) { 
s += sep; 
} 
s += strings[i]; 
} 
return s; 
} 
var rKeyPattern = new RegExp(/(\{@[^\}]*\})/); 
var rKey = new RegExp(/\{@([^\}]*)\}/); 
function performKeywordSubs(s, subs){ 
var sa = s.split(rKeyPattern); 
for (var i in sa){ 
var p = sa[i]; 
var m = rKey.exec(p); 
if (m && (_AN_Read_length('length', m) > 1)) { 
var k = m[1]; 
if (subs && !!subs[k]) { 
sa[i] = subs[k]; 
} 
} 
} 
return join(sa); 
} 
function formatIDLDoc(args){ 
var d = findIDL(args[0]); 
if (d) { 
return formatIDLDefinitionDoc(d, args); 
} 
 else { 
return ''; 
} 
} 
function formatIDLDefinitionDoc(def, args){ 
for (var i in def.extAttrs){ 
var xa = def.extAttrs[i]; 
if (!!xa.name && (xa.name == 'Documentation')) { 
return performKeywordSubs(xa.value || '', collectIDLDefinitionKeywords(def, args)); 
} 
} 
return ''; 
} 
function getIDLConstructorCount(def){ 
return !!def.constructors? _AN_Read_length('length', def.constructors): 0; 
} 
function collectIDLDefinitionKeywords(def, args){ 
return { 
type: def.type,
name: formatAsCode(def.name),
link: formatIDLDefinitionNameAsLink(def, args),
memberCount: !!def.members? _AN_Read_length('length', def.members): 0,
constructorCount: countConstructorMembers(def, args)}
; 
} 
function formatIDLDefinitionNameAsLink(def, args){ 
return formatAsLink(def.name, 'idlType', generateIDRef(generateIDLDefinitionID(def, args)), args); 
} 
function formatNamedIDLDefinitionNameAsLink(name, args){ 
if (name) { 
var d = findIDL(name); 
if (d) { 
return formatIDLDefinitionNameAsLink(d, args); 
} 
 else { 
return formatAsCode(name); 
} 
} 
 else { 
return ''; 
} 
} 
function formatIDLDocMembers(args){ 
var d = findIDL(args[0]); 
if (d) { 
return formatIDLDefinitionDocMembers(d, args); 
} 
 else { 
return ''; 
} 
} 
function formatIDLDefinitionDocMembers(def, args){ 
if (hasArg(args, 'uncollatedMembers')) { 
return formatIDLDefinitionDocMembersUncollated(def, args); 
} 
 else { 
return formatIDLDefinitionDocMembersCollated(def, args); 
} 
} 
function countConstMembers(def, args){ 
return countMembers('const', def, args); 
} 
function countAttrMembers(def, args){ 
return countMembers('attribute', def, args); 
} 
function countOperMembers(def, args){ 
return countMembers('operation', def, args); 
} 
function countConstructorMembers(def, args){ 
return countMembers('constructor', def, args); 
} 
function countMembers(type, def, args){ 
var n = 0; 
for (var i in def.members){ 
var m = def.members[i]; 
if (m.type == type) { 
n++ ; 
} 
} 
return n; 
} 
function formatIDLDefinitionDocMembersCollated(def, args){ 
var s = ''; 
if (countConstructorMembers(def, args) > 0) { 
s += formatIDLDefinitionDocConstructorMembers(def, args); 
} 
if (countConstMembers(def, args) > 0) { 
s += formatIDLDefinitionDocConstMembers(def, args); 
} 
if (countAttrMembers(def, args) > 0) { 
s += formatIDLDefinitionDocAttrMembers(def, args); 
} 
if (countOperMembers(def, args) > 0) { 
s += formatIDLDefinitionDocOperMembers(def, args); 
} 
return s; 
} 
function formatIDLDefinitionDocMembersUncollated(def, args){ 
return formatIDLDefinitionDocAllMembers(def, args); 
} 
function formatIDLDefinitionDocConstMembers(def, args){ 
return formatIDLDefinitionDocMembersByType('const', def, args); 
} 
function formatIDLDefinitionDocAttrMembers(def, args){ 
return formatIDLDefinitionDocMembersByType('attribute', def, args); 
} 
function formatIDLDefinitionDocOperMembers(def, args){ 
return formatIDLDefinitionDocMembersByType('operation', def, args); 
} 
function formatIDLDefinitionDocConstructorMembers(def, args){ 
return formatIDLDefinitionDocMembersByType('constructor', def, args); 
} 
function formatIDLDefinitionDocAllMembers(def, args){ 
return formatIDLDefinitionDocMembersByType(null , def, args); 
} 
function getIDLDefinitionListCSSClass(type){ 
if (type == 'const') { 
return 'constants'; 
} 
 else if (type == 'attribute') { 
return 'attributes'; 
} 
 else if (type == 'operation') { 
return 'methods'; 
} 
 else if (type == 'constructor') { 
return 'constructors'; 
} 
 else { 
return 'members'; 
} 
} 
function formatIDLDefinitionDocMembersByType(type, def, args){ 
var s = ''; 
var c = getIDLDefinitionListCSSClass(type); 
s += formatIDLDefinitionDocMembersHeader(type, def, args, c); 
s += eltStart('dl', [newAttr('class', c)] , true ); 
for (var i in def.members){ 
var m = def.members[i]; 
if (!type || (m.type == type)) { 
s += formatIDLMemberTerm(def, m, args); 
s += formatIDLMemberDefinition(def, m, args); 
} 
} 
s += eltEnd('dl', true ); 
return s; 
} 
function formatIDLDefinitionDocMembersHeader(type, def, args, cssClass){ 
var s = ''; 
if (hasArg(args, 'level')) { 
var level = parseInt(getArgValue(args, 'level')) + 1; 
var heading = 'h' + level; 
s += eltStart(heading, [newAttr('class', 'no-toc'), newAttr('id', generateIDLOtherID(def) + '-' + cssClass)] , false ); 
s += getIDLMembersHeader(cssClass); 
s += eltEnd(heading, true ); 
} 
return s; 
} 
function formatIDLMemberTerm(def, mem, args){ 
var getDTAttrs = function (def, mem, args){ 
return [newAttr('class', getIDLMemberTermCSSClass(def, mem, args)), newAttr('id', getIDLMemberID(def, mem, args))] ; 
} 
; 
return wrap(formatIDLMemberTermContent(def, mem, args), 'dt', getDTAttrs, true , def, mem, args); 
} 
function formatIDLMemberTermContent(def, mem, args){ 
var s = formatAsCode(mem.name); 
if (mem.type == 'const') { 
s += formatIDLConstSignature(def, mem, true , args); 
} 
 else if (mem.type == 'attribute') { 
s += formatIDLAttrSignature(def, mem, true , args); 
} 
 else if (mem.type == 'operation') { 
s += formatIDLOperSignature(def, mem, true , args); 
} 
 else if (mem.type == 'constructor') { 
s += formatIDLOperSignature(def, mem, false , args); 
} 
return s; 
} 
function wrapIDLMemberDD(s, def, mem, args){ 
return wrap(s, 'dd', null , true , def, mem, args); 
} 
function formatIDLMemberDefinition(def, mem, args){ 
for (var i in mem.extAttrs){ 
var xa = mem.extAttrs[i]; 
if (!!xa.name && (xa.name == 'Documentation')) { 
return wrapIDLMemberDD(performKeywordSubs(xa.value || '', collectIDLMemberKeywords(def, mem, args)), def, mem, args); 
} 
} 
return ''; 
} 
function getIDLOperParamsSignature(mem, sep){ 
var s = ''; 
for (var i in mem.arguments){ 
var a = mem.arguments[i]; 
if (sep && (_AN_Read_length('length', s) > 0)) { 
s += sep; 
} 
} 
return s; 
} 
function getIDLMemberSignature(mem){ 
if (mem.type == 'operation') { 
return '(' + getIDLOperParamsSignature(mem, ',') + ')'; 
} 
 else if (mem.type == 'constructor') { 
return '(' + getIDLOperParamsSignature(mem, ',') + ')'; 
} 
 else { 
return ''; 
} 
} 
function collectIDLMemberKeywords(def, mem, args){ 
return { 
type: mem.type,
name: formatAsCode(mem.name),
link: formatIDLMemberNameAsLink(def, mem, args),
signature: getIDLMemberSignature(mem)}
; 
} 
function formatIDLMemberNameAsLink(def, mem, args){ 
return formatAsLink(mem.name, getIDLMemberCSSClass(def, mem, args), generateIDRef(generateIDLMemberID(def, mem, args)), args); 
} 
function newAttr(n, v){ 
return { 
nodeName: n,
nodeValue: v}
; 
} 
function eltStartMaybeEmpty(ln, attrs, empty, newLine){ 
var s = '<' + ln; 
for (var i in attrs){ 
var a = attrs[i]; 
s += ' ' + formatAttr(a, ln); 
} 
if (empty) { 
s += '/'; 
} 
s += '>' + (newLine? eol: ''); 
return s; 
} 
function eltEmpty(ln, attrs, newLine){ 
return eltStartMaybeEmpty(ln, attrs, true , newLine); 
} 
function eltStart(ln, attrs, newLine){ 
return eltStartMaybeEmpty(ln, attrs, false , newLine); 
} 
function eltEnd(ln, newLine){ 
var s = '</' + ln + '>' + (newLine? eol: ''); 
return s; 
} 
function formatAsCode(s){ 
return wrap(s, 'code'); 
} 
function formatAsLink(inner, cssClass, href, args){ 
var s = ''; 
var aa = [] ; 
if (!!cssClass) { 
aa.push(newAttr('class', cssClass)); 
} 
if (!!href) { 
aa.push(newAttr('href', href)); 
} 
s += eltStart('a', aa); 
s += formatAsCode(inner); 
s += eltEnd('a'); 
return s; 
} 
var rQuote = new RegExp('[' + html5.SPACE_CHARACTERS_IN + '<=>\'\"' + ']'); 
var alwaysQuote = true ; 
function formatAttr(a, ln){ 
var n = a.nodeName; 
var v = _AN_Read_nodevalue('nodeValue', a); 
var s = n; 
if (!isBooleanAttr(ln, n)) { 
var quote = alwaysQuote || (_AN_Read_length('length', v) == 0) || rQuote.test(v); 
s += '='; 
if (quote) { 
s += '"'; 
} 
v = _AN_Call_replace('replace', v, /&/g, '&amp;'); 
v = _AN_Call_replace('replace', v, /\"/g, '&quot;'); 
v = _AN_Call_replace('replace', v, /</g, '&lt;'); 
v = _AN_Call_replace('replace', v, />/g, '&gt;'); 
s += v; 
if (quote) { 
s += '"'; 
} 
} 
return s; 
} 
function formatChars(chars, ln){ 
var newChars = chars; 
newChars = _AN_Call_replace('replace', newChars, /&/g, '&amp;'); 
newChars = _AN_Call_replace('replace', newChars, /</g, '&lt;'); 
newChars = _AN_Call_replace('replace', newChars, />/g, '&gt;'); 
return newChars; 
} 
var $ = { 
ondata: function (data){ 
output += data; 
} 
,
ontoken: function (token){ 
if (token.type == 'Doctype') { 
$.ondata('<!DOCTYPE ' + token.name.toLowerCase() + '>' + eol); 
} 
 else if ((token.type == 'Characters') || (token.type == 'SpaceCharacters')) { 
$.ondata(formatChars(token.data)); 
} 
 else if ((token.type == 'StartTag') || (token.type == 'EmptyTag')) { 
var ln = token.name.toLowerCase(); 
var attrs = [] ; 
for (var i = 0, n = _AN_Read_length('length', token.data); 
i < n; i++ ){ 
attrs.push(token.data.item(i)); 
} 
var attributes = ''; 
for (var i in attrs){ 
var a = attrs[i]; 
attributes += ' ' + formatAttr(a, ln); 
} 
$.ondata('<' + ln + attributes + ((token.type == 'EmptyTag')? '/': '') + '>' + needsEOL(ln, false )); 
} 
 else if (token.type == 'EndTag') { 
var ln = token.name.toLowerCase(); 
$.ondata('</' + ln + '>' + needsEOL(ln, true )); 
} 
 else if (token.type == 'Comment') { 
if (isIDLComment(token.data)) { 
$.ondata(processIDLComment(token.data)); 
} 
 else { 
$.ondata('<!--' + token.data + '-->'); 
} 
} 
 else { 
} 
} 
,
onend: function (){ 
new html5.TreeWalker(parser.tree.document, $.ontoken); 
util.puts(output); 
} 
,
run: function (argv){ 
var argc = _AN_Read_length('length', argv) - 2; 
if (argc < 1) { 
util.error("Error: Missing JSONFILE argument."); 
process.exit(2); 
} 
 else if (argc < 2) { 
util.error("Error: Missing INPUTFILE argument."); 
process.exit(2); 
} 
 else { 
try { 
var jsonFile = argv[argc++ ]; 
var inFile = argv[argc++ ]; 
var sIdl = fs.readFileSync(jsonFile, 'utf8'); 
idl = augmentIDL(JSON.parse(sIdl)); 
var sDoc = fs.createReadStream(inFile); 
parser.on('end', $.onend); 
parser.parse(sDoc); 
} 
catch (e) { 
util.error(util.inspect(e)); 
process.exit(1); 
} 
} 
} 
}
; 
$.run(process.argv); 
} 
)();