fragments and .js files.",
+ adsafe_id: "ADsafe violation: id does not match.",
+ adsafe_id_go: "ADsafe violation: Missing ADSAFE.id or ADSAFE.go.",
+ adsafe_lib: "ADsafe lib violation.",
+ adsafe_lib_second: "ADsafe: The second argument to lib must be a function.",
+ adsafe_missing_id: "ADSAFE violation: missing ID_.",
+ adsafe_name_a: "ADsafe name violation: '{a}'.",
+ adsafe_placement: "ADsafe script placement violation.",
+ adsafe_prefix_a: "ADsafe violation: An id must have a '{a}' prefix",
+ adsafe_script: "ADsafe script violation.",
+ adsafe_source: "ADsafe unapproved script source.",
+ adsafe_subscript_a: "ADsafe subscript '{a}'.",
+ adsafe_tag: "ADsafe violation: Disallowed tag '{a}'.",
+ already_defined: "'{a}' is already defined.",
+ and: "The '&&' subexpression should be wrapped in parens.",
+ assign_exception: "Do not assign to the exception parameter.",
+ assignment_function_expression: "Expected an assignment or " +
+ "function call and instead saw an expression.",
+ attribute_case_a: "Attribute '{a}' not all lower case.",
+ avoid_a: "Avoid '{a}'.",
+ bad_assignment: "Bad assignment.",
+ bad_color_a: "Bad hex color '{a}'.",
+ bad_constructor: "Bad constructor.",
+ bad_entity: "Bad entity.",
+ bad_html: "Bad HTML string",
+ bad_id_a: "Bad id: '{a}'.",
+ bad_in_a: "Bad for in variable '{a}'.",
+ bad_invocation: "Bad invocation.",
+ bad_name_a: "Bad name: '{a}'.",
+ bad_new: "Do not use 'new' for side effects.",
+ bad_number: "Bad number '{a}'.",
+ bad_operand: "Bad operand.",
+ bad_style: "Bad style.",
+ bad_type: "Bad type.",
+ bad_url_a: "Bad url '{a}'.",
+ bad_wrap: "Do not wrap function literals in parens unless they " +
+ "are to be immediately invoked.",
+ combine_var: "Combine this with the previous 'var' statement.",
+ conditional_assignment: "Expected a conditional expression and " +
+ "instead saw an assignment.",
+ confusing_a: "Confusing use of '{a}'.",
+ confusing_regexp: "Confusing regular expression.",
+ constructor_name_a: "A constructor name '{a}' should start with " +
+ "an uppercase letter.",
+ control_a: "Unexpected control character '{a}'.",
+ css: "A css file should begin with @charset 'UTF-8';",
+ dangling_a: "Unexpected dangling '_' in '{a}'.",
+ dangerous_comment: "Dangerous comment.",
+ deleted: "Only properties should be deleted.",
+ duplicate_a: "Duplicate '{a}'.",
+ empty_block: "Empty block.",
+ empty_case: "Empty case.",
+ empty_class: "Empty class.",
+ es5: "This is an ES5 feature.",
+ evil: "eval is evil.",
+ expected_a: "Expected '{a}'.",
+ expected_a_b: "Expected '{a}' and instead saw '{b}'.",
+ expected_a_b_from_c_d: "Expected '{a}' to match '{b}' from line " +
+ "{c} and instead saw '{d}'.",
+ expected_at_a: "Expected an at-rule, and instead saw @{a}.",
+ expected_a_at_b_c: "Expected '{a}' at column {b}, not column {c}.",
+ expected_attribute_a: "Expected an attribute, and instead saw [{a}].",
+ expected_attribute_value_a: "Expected an attribute value and " +
+ "instead saw '{a}'.",
+ expected_class_a: "Expected a class, and instead saw .{a}.",
+ expected_fraction_a: "Expected a number between 0 and 1 and " +
+ "instead saw '{a}'",
+ expected_id_a: "Expected an id, and instead saw #{a}.",
+ expected_identifier_a: "Expected an identifier and instead saw '{a}'.",
+ expected_identifier_a_reserved: "Expected an identifier and " +
+ "instead saw '{a}' (a reserved word).",
+ expected_linear_a: "Expected a linear unit and instead saw '{a}'.",
+ expected_lang_a: "Expected a lang code, and instead saw :{a}.",
+ expected_media_a: "Expected a CSS media type, and instead saw '{a}'.",
+ expected_name_a: "Expected a name and instead saw '{a}'.",
+ expected_nonstandard_style_attribute: "Expected a non-standard " +
+ "style attribute and instead saw '{a}'.",
+ expected_number_a: "Expected a number and instead saw '{a}'.",
+ expected_operator_a: "Expected an operator and instead saw '{a}'.",
+ expected_percent_a: "Expected a percentage and instead saw '{a}'",
+ expected_positive_a: "Expected a positive number and instead saw '{a}'",
+ expected_pseudo_a: "Expected a pseudo, and instead saw :{a}.",
+ expected_selector_a: "Expected a CSS selector, and instead saw {a}.",
+ expected_small_a: "Expected a small positive integer and instead saw '{a}'",
+ expected_space_a_b: "Expected exactly one space between '{a}' and '{b}'.",
+ expected_string_a: "Expected a string and instead saw '{a}'.",
+ expected_style_attribute: "Excepted a style attribute, and instead saw '{a}'.",
+ expected_style_pattern: "Expected a style pattern, and instead saw '{a}'.",
+ expected_tagname_a: "Expected a tagName, and instead saw {a}.",
+ expected_type_a: "Expected a type, and instead saw {a}.",
+ for_if: "The body of a for in should be wrapped in an if " +
+ "statement to filter unwanted properties from the prototype.",
+ function_block: "Function statements should not be placed in blocks." +
+ "Use a function expression or move the statement to the top of " +
+ "the outer function.",
+ function_eval: "The Function constructor is eval.",
+ function_loop: "Don't make functions within a loop.",
+ function_statement: "Function statements are not invocable." +
+ "Wrap the whole function invocation in parens.",
+ function_strict: "Use the function form of 'use strict'.",
+ html_confusion_a: "HTML confusion in regular expression '<{a}'.",
+ html_handlers: "Avoid HTML event handlers.",
+ identifier_function: "Expected an identifier in an assignment " +
+ "and instead saw a function invocation.",
+ implied_evil: "Implied eval is evil. Pass a function instead of a string.",
+ infix_in: "Unexpected 'in'. Compare with undefined, or use the " +
+ "hasOwnProperty method instead.",
+ insecure_a: "Insecure '{a}'.",
+ isNaN: "Use the isNaN function to compare with NaN.",
+ lang: "lang is deprecated.",
+ leading_decimal_a: "A leading decimal point can be confused with a dot: '.{a}'.",
+ missing_a: "Missing '{a}'.",
+ missing_a_after_b: "Missing '{a}' after '{b}'.",
+ missing_option: "Missing option value.",
+ missing_property: "Missing property name.",
+ missing_space_a_b: "Missing space between '{a}' and '{b}'.",
+ missing_url: "Missing url.",
+ missing_use_strict: "Missing 'use strict' statement.",
+ move_invocation: "Move the invocation into the parens that " +
+ "contain the function.",
+ move_var: "Move 'var' declarations to the top of the function.",
+ name_function: "Missing name in function statement.",
+ nested_comment: "Nested comment.",
+ not: "Nested not.",
+ not_a_constructor: "Do not use {a} as a constructor.",
+ not_a_defined: "'{a}' has not been fully defined yet.",
+ not_a_function: "'{a}' is not a function.",
+ not_a_label: "'{a}' is not a label.",
+ not_a_scope: "'{a}' is out of scope.",
+ not_greater: "'{a}' should not be greater than '{b}'.",
+ octal_a: "Don't use octal: '{a}'. Use '\\u....' instead.",
+ parameter_arguments_a: "Do not mutate parameter '{a}' when using 'arguments'.",
+ parameter_a_get_b: "Unexpected parameter '{a}' in get {b} function.",
+ parameter_set_a: "Expected parameter (value) in set {a} function.",
+ radix: "Missing radix parameter.",
+ read_only: "Read only.",
+ redefinition_a: "Redefinition of '{a}'.",
+ reserved_a: "Reserved name '{a}'.",
+ scanned_a_b: "{a} ({b}% scanned).",
+ slash_equal: "A regular expression literal can be confused with '/='.",
+ statement_block: "Expected to see a statement and instead saw a block.",
+ stopping: "Stopping.",
+ strange_loop: "Strange loop.",
+ strict: "Strict violation.",
+ subscript: "['{a}'] is better written in dot notation.",
+ sync_a: "Unexpected sync method: '{a}'.",
+ tag_a_in_b: "A '<{a}>' must be within '<{b}>'.",
+ todo_comment: "Unexpected TODO comment.",
+ too_long: "Line too long.",
+ too_many: "Too many errors.",
+ trailing_decimal_a: "A trailing decimal point can be confused " +
+ "with a dot: '.{a}'.",
+ type: "type is unnecessary.",
+ unclosed: "Unclosed string.",
+ unclosed_comment: "Unclosed comment.",
+ unclosed_regexp: "Unclosed regular expression.",
+ unescaped_a: "Unescaped '{a}'.",
+ unexpected_a: "Unexpected '{a}'.",
+ unexpected_char_a_b: "Unexpected character '{a}' in {b}.",
+ unexpected_comment: "Unexpected comment.",
+ unexpected_else: "Unexpected 'else' after 'return'.",
+ unexpected_label_a: "Unexpected label '{a}'.",
+ unexpected_property_a: "Unexpected /*property*/ '{a}'.",
+ unexpected_space_a_b: "Unexpected space between '{a}' and '{b}'.",
+ unexpected_typeof_a: "Unexpected 'typeof'. " +
+ "Use '===' to compare directly with {a}.",
+ unnecessary_initialize: "It is not necessary to initialize '{a}' " +
+ "to 'undefined'.",
+ unnecessary_use: "Unnecessary 'use strict'.",
+ unreachable_a_b: "Unreachable '{a}' after '{b}'.",
+ unrecognized_style_attribute_a: "Unrecognized style attribute '{a}'.",
+ unrecognized_tag_a: "Unrecognized tag '<{a}>'.",
+ unsafe: "Unsafe character.",
+ url: "JavaScript URL.",
+ use_array: "Use the array literal notation [].",
+ use_braces: "Spaces are hard to count. Use {{a}}.",
+ use_charAt: "Use the charAt method.",
+ use_object: "Use the object literal notation {}.",
+ use_or: "Use the || operator.",
+ use_param: "Use a named parameter.",
+ use_spaces: "Use spaces, not tabs.",
+ used_before_a: "'{a}' was used before it was defined.",
+ var_a_not: "Variable {a} was not declared correctly.",
+ weird_assignment: "Weird assignment.",
+ weird_condition: "Weird condition.",
+ weird_new: "Weird construction. Delete 'new'.",
+ weird_program: "Weird program.",
+ weird_relation: "Weird relation.",
+ weird_ternary: "Weird ternary.",
+ wrap_immediate: "Wrap an immediate function invocation in parentheses " +
+ "to assist the reader in understanding that the expression " +
+ "is the result of a function, and not the function itself.",
+ wrap_regexp: "Wrap the /regexp/ literal in parens to " +
+ "disambiguate the slash operator.",
+ write_is_wrong: "document.write can be a form of eval."
+ },
+ comments_off,
+ css_attribute_data,
+ css_any,
+
+ css_colorData = array_to_object([
+ "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
+ "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
+ "burlywood", "cadetblue", "chartreuse", "chocolate", "coral",
+ "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue",
+ "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkkhaki",
+ "darkmagenta", "darkolivegreen", "darkorange", "darkorchid",
+ "darkred", "darksalmon", "darkseagreen", "darkslateblue",
+ "darkslategray", "darkturquoise", "darkviolet", "deeppink",
+ "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite",
+ "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold",
+ "goldenrod", "gray", "green", "greenyellow", "honeydew", "hotpink",
+ "indianred", "indigo", "ivory", "khaki", "lavender",
+ "lavenderblush", "lawngreen", "lemonchiffon", "lightblue",
+ "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgreen",
+ "lightpink", "lightsalmon", "lightseagreen", "lightskyblue",
+ "lightslategray", "lightsteelblue", "lightyellow", "lime",
+ "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
+ "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
+ "mediumslateblue", "mediumspringgreen", "mediumturquoise",
+ "mediumvioletred", "midnightblue", "mintcream", "mistyrose",
+ "moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab",
+ "orange", "orangered", "orchid", "palegoldenrod", "palegreen",
+ "paleturquoise", "palevioletred", "papayawhip", "peachpuff",
+ "peru", "pink", "plum", "powderblue", "purple", "red", "rosybrown",
+ "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen",
+ "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray",
+ "snow", "springgreen", "steelblue", "tan", "teal", "thistle",
+ "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke",
+ "yellow", "yellowgreen",
+
+ "activeborder", "activecaption", "appworkspace", "background",
+ "buttonface", "buttonhighlight", "buttonshadow", "buttontext",
+ "captiontext", "graytext", "highlight", "highlighttext",
+ "inactiveborder", "inactivecaption", "inactivecaptiontext",
+ "infobackground", "infotext", "menu", "menutext", "scrollbar",
+ "threeddarkshadow", "threedface", "threedhighlight",
+ "threedlightshadow", "threedshadow", "window", "windowframe",
+ "windowtext"
+ ], true),
+
+ css_border_style,
+ css_break,
+
+ css_lengthData = {
+ '%': true,
+ 'cm': true,
+ 'em': true,
+ 'ex': true,
+ 'in': true,
+ 'mm': true,
+ 'pc': true,
+ 'pt': true,
+ 'px': true
+ },
+
+ css_media,
+ css_overflow,
+
+ descapes = {
+ 'b': '\b',
+ 't': '\t',
+ 'n': '\n',
+ 'f': '\f',
+ 'r': '\r',
+ '"': '"',
+ '/': '/',
+ '\\': '\\',
+ '!': '!'
+ },
+
+ devel = array_to_object([
+ 'alert', 'confirm', 'console', 'Debug', 'opera', 'prompt', 'WSH'
+ ], false),
+ directive,
+ escapes = {
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '\'': '\\\'',
+ '"' : '\\"',
+ '/' : '\\/',
+ '\\': '\\\\'
+ },
+
+ funct, // The current function, including the labels used in
+ // the function, as well as (breakage),
+ // (context), (loopage), (name), (params), (token),
+ // (vars), (verb)
+
+ functionicity = [
+ 'closure', 'exception', 'global', 'label', 'outer', 'undef',
+ 'unused', 'var'
+ ],
+
+ functions, // All of the functions
+ global_funct, // The global body
+ global_scope, // The global scope
+ html_tag = {
+ a: {},
+ abbr: {},
+ acronym: {},
+ address: {},
+ applet: {},
+ area: {empty: true, parent: ' map '},
+ article: {},
+ aside: {},
+ audio: {},
+ b: {},
+ base: {empty: true, parent: ' head '},
+ bdo: {},
+ big: {},
+ blockquote: {},
+ body: {parent: ' html noframes '},
+ br: {empty: true},
+ button: {},
+ canvas: {parent: ' body p div th td '},
+ caption: {parent: ' table '},
+ center: {},
+ cite: {},
+ code: {},
+ col: {empty: true, parent: ' table colgroup '},
+ colgroup: {parent: ' table '},
+ command: {parent: ' menu '},
+ datalist: {},
+ dd: {parent: ' dl '},
+ del: {},
+ details: {},
+ dialog: {},
+ dfn: {},
+ dir: {},
+ div: {},
+ dl: {},
+ dt: {parent: ' dl '},
+ em: {},
+ embed: {},
+ fieldset: {},
+ figcaption: {parent: ' figure '},
+ figure: {},
+ font: {},
+ footer: {},
+ form: {},
+ frame: {empty: true, parent: ' frameset '},
+ frameset: {parent: ' html frameset '},
+ h1: {},
+ h2: {},
+ h3: {},
+ h4: {},
+ h5: {},
+ h6: {},
+ head: {parent: ' html '},
+ header: {},
+ hgroup: {},
+ hr: {empty: true},
+ 'hta:application':
+ {empty: true, parent: ' head '},
+ html: {parent: '*'},
+ i: {},
+ iframe: {},
+ img: {empty: true},
+ input: {empty: true},
+ ins: {},
+ kbd: {},
+ keygen: {},
+ label: {},
+ legend: {parent: ' details fieldset figure '},
+ li: {parent: ' dir menu ol ul '},
+ link: {empty: true, parent: ' head '},
+ map: {},
+ mark: {},
+ menu: {},
+ meta: {empty: true, parent: ' head noframes noscript '},
+ meter: {},
+ nav: {},
+ noframes: {parent: ' html body '},
+ noscript: {parent: ' body head noframes '},
+ object: {},
+ ol: {},
+ optgroup: {parent: ' select '},
+ option: {parent: ' optgroup select '},
+ output: {},
+ p: {},
+ param: {empty: true, parent: ' applet object '},
+ pre: {},
+ progress: {},
+ q: {},
+ rp: {},
+ rt: {},
+ ruby: {},
+ samp: {},
+ script: {empty: true, parent: ' body div frame head iframe p pre span '},
+ section: {},
+ select: {},
+ small: {},
+ span: {},
+ source: {},
+ strong: {},
+ style: {parent: ' head ', empty: true},
+ sub: {},
+ summary: {parent: ' details '},
+ sup: {},
+ table: {},
+ tbody: {parent: ' table '},
+ td: {parent: ' tr '},
+ textarea: {},
+ tfoot: {parent: ' table '},
+ th: {parent: ' tr '},
+ thead: {parent: ' table '},
+ time: {},
+ title: {parent: ' head '},
+ tr: {parent: ' table tbody thead tfoot '},
+ tt: {},
+ u: {},
+ ul: {},
+ 'var': {},
+ video: {}
+ },
+
+ ids, // HTML ids
+ in_block,
+ indent,
+ itself, // JSLint itself
+ json_mode,
+ lex, // the tokenizer
+ lines,
+ lookahead,
+ node = array_to_object([
+ 'Buffer', 'clearInterval', 'clearTimeout', 'console', 'exports',
+ 'global', 'module', 'process', 'querystring', 'require',
+ 'setInterval', 'setTimeout', '__dirname', '__filename'
+ ], false),
+ node_js,
+ numbery = array_to_object(['indexOf', 'lastIndexOf', 'search'], true),
+ next_token,
+ option,
+ predefined, // Global variables defined by option
+ prereg,
+ prev_token,
+ property,
+ regexp_flag = array_to_object(['g', 'i', 'm'], true),
+ return_this = function return_this() {
+ return this;
+ },
+ rhino = array_to_object([
+ 'defineClass', 'deserialize', 'gc', 'help', 'load', 'loadClass',
+ 'print', 'quit', 'readFile', 'readUrl', 'runCommand', 'seal',
+ 'serialize', 'spawn', 'sync', 'toint32', 'version'
+ ], false),
+
+ scope, // An object containing an object for each variable in scope
+ semicolon_coda = array_to_object([';', '"', '\'', ')'], true),
+ src,
+ stack,
+
+// standard contains the global names that are provided by the
+// ECMAScript standard.
+
+ standard = array_to_object([
+ 'Array', 'Boolean', 'Date', 'decodeURI', 'decodeURIComponent',
+ 'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError',
+ 'Function', 'isFinite', 'isNaN', 'JSON', 'Math', 'Number',
+ 'Object', 'parseInt', 'parseFloat', 'RangeError', 'ReferenceError',
+ 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError'
+ ], false),
+
+ strict_mode,
+ syntax = {},
+ tab,
+ token,
+ tokens,
+ urls,
+ var_mode,
+ warnings,
+
+ windows = array_to_object([
+ 'ActiveXObject', 'CScript', 'Debug', 'Enumerator', 'System',
+ 'VBArray', 'WScript', 'WSH'
+ ], false),
+
+// xmode is used to adapt to the exceptions in html parsing.
+// It can have these states:
+// '' .js script file
+// 'html'
+// 'outer'
+// 'script'
+// 'style'
+// 'scriptstring'
+// 'styleproperty'
+
+ xmode,
+ xquote,
+
+// Regular expressions. Some of these are stupidly long.
+
+// unsafe comment or string
+ ax = /@cc|<\/?|script|\]\s*\]|<\s*!|</i,
+// carriage return, carriage return linefeed, or linefeed
+ crlfx = /\r\n?|\n/,
+// unsafe characters that are silently deleted by one or more browsers
+ cx = /[\u0000-\u0008\u000a-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/,
+// query characters for ids
+ dx = /[\[\]\/\\"'*<>.&:(){}+=#]/,
+// html token
+ hx = /^\s*(['"=>\/&#]|<(?:\/|\!(?:--)?)?|[a-zA-Z][a-zA-Z0-9_\-:]*|[0-9]+|--)/,
+// identifier
+ ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/,
+// javascript url
+ jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i,
+// star slash
+ lx = /\*\/|\/\*/,
+// characters in strings that need escapement
+ nx = /[\u0000-\u001f'\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+// outer html token
+ ox = /[>&]|<[\/!]?|--/,
+// attributes characters
+ qx = /[^a-zA-Z0-9+\-_\/. ]/,
+// style
+ ssx = /^\s*([@#!"'};:\-%.=,+\[\]()*_]|[a-zA-Z][a-zA-Z0-9._\-]*|\/\*?|\d+(?:\.\d+)?|<\/)/,
+ sx = /^\s*([{}:#%.=,>+\[\]@()"';]|[*$\^~]=|[a-zA-Z_][a-zA-Z0-9_\-]*|[0-9]+|<\/|\/\*)/,
+
+// sync
+ syx = /Sync$/,
+// comment todo
+ tox = /^\W*to\s*do(?:\W|$)/i,
+// token
+ tx = /^\s*([(){}\[\]\?.,:;'"~#@`]|={1,3}|\/(\*(jslint|properties|property|members?|globals?)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|[\^%]=?|&[&=]?|\|[|=]?|>{1,3}=?|<(?:[\/=!]|\!(\[|--)?|<=?)?|\!(\!|==?)?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+(?:[xX][0-9a-fA-F]+|\.[0-9]*)?(?:[eE][+\-]?[0-9]+)?)/,
+// url badness
+ ux = /&|\+|\u00AD|\.\.|\/\*|%[^;]|base64|url|expression|data|mailto|script/i,
+
+ rx = {
+ outer: hx,
+ html: hx,
+ style: sx,
+ styleproperty: ssx
+ };
+
+
+ function F() {} // Used by Object.create
+
+// Provide critical ES5 functions to ES3.
+
+ if (typeof Array.prototype.filter !== 'function') {
+ Array.prototype.filter = function (f) {
+ var i, length = this.length, result = [], value;
+ for (i = 0; i < length; i += 1) {
+ try {
+ value = this[i];
+ if (f(value)) {
+ result.push(value);
+ }
+ } catch (ignore) {
+ }
+ }
+ return result;
+ };
+ }
+
+ if (typeof Array.prototype.forEach !== 'function') {
+ Array.prototype.forEach = function (f) {
+ var i, length = this.length;
+ for (i = 0; i < length; i += 1) {
+ try {
+ f(this[i]);
+ } catch (ignore) {
+ }
+ }
+ };
+ }
+
+ if (typeof Array.isArray !== 'function') {
+ Array.isArray = function (o) {
+ return Object.prototype.toString.apply(o) === '[object Array]';
+ };
+ }
+
+ if (!Object.prototype.hasOwnProperty.call(Object, 'create')) {
+ Object.create = function (o) {
+ F.prototype = o;
+ return new F();
+ };
+ }
+
+ if (typeof Object.keys !== 'function') {
+ Object.keys = function (o) {
+ var array = [], key;
+ for (key in o) {
+ if (Object.prototype.hasOwnProperty.call(o, key)) {
+ array.push(key);
+ }
+ }
+ return array;
+ };
+ }
+
+ if (typeof String.prototype.entityify !== 'function') {
+ String.prototype.entityify = function () {
+ return this
+ .replace(/&/g, '&')
+ .replace(//g, '>');
+ };
+ }
+
+ if (typeof String.prototype.isAlpha !== 'function') {
+ String.prototype.isAlpha = function () {
+ return (this >= 'a' && this <= 'z\uffff') ||
+ (this >= 'A' && this <= 'Z\uffff');
+ };
+ }
+
+ if (typeof String.prototype.isDigit !== 'function') {
+ String.prototype.isDigit = function () {
+ return (this >= '0' && this <= '9');
+ };
+ }
+
+ if (typeof String.prototype.supplant !== 'function') {
+ String.prototype.supplant = function (o) {
+ return this.replace(/\{([^{}]*)\}/g, function (a, b) {
+ var replacement = o[b];
+ return typeof replacement === 'string' ||
+ typeof replacement === 'number' ? replacement : a;
+ });
+ };
+ }
+
+
+ function sanitize(a) {
+
+// Escapify a troublesome character.
+
+ return escapes[a] ||
+ '\\u' + ('0000' + a.charCodeAt().toString(16)).slice(-4);
+ }
+
+
+ function add_to_predefined(group) {
+ Object.keys(group).forEach(function (name) {
+ predefined[name] = group[name];
+ });
+ }
+
+
+ function assume() {
+ if (!option.safe) {
+ if (option.rhino) {
+ add_to_predefined(rhino);
+ option.rhino = false;
+ }
+ if (option.devel) {
+ add_to_predefined(devel);
+ option.devel = false;
+ }
+ if (option.browser) {
+ add_to_predefined(browser);
+ option.browser = false;
+ }
+ if (option.windows) {
+ add_to_predefined(windows);
+ option.windows = false;
+ }
+ if (option.node) {
+ add_to_predefined(node);
+ option.node = false;
+ node_js = true;
+ }
+ }
+ }
+
+
+// Produce an error warning.
+
+ function artifact(tok) {
+ if (!tok) {
+ tok = next_token;
+ }
+ return tok.number || tok.string;
+ }
+
+ function quit(message, line, character) {
+ throw {
+ name: 'JSLintError',
+ line: line,
+ character: character,
+ message: bundle.scanned_a_b.supplant({
+ a: message,
+ b: Math.floor((line / lines.length) * 100)
+ })
+ };
+ }
+
+ function warn(message, offender, a, b, c, d) {
+ var character, line, warning;
+ offender = offender || next_token; // ~~
+ line = offender.line || 0;
+ character = offender.from || 0;
+ warning = {
+ id: '(error)',
+ raw: bundle[message] || message,
+ evidence: lines[line - 1] || '',
+ line: line,
+ character: character,
+ a: a || (offender.id === '(number)'
+ ? String(offender.number)
+ : offender.string),
+ b: b,
+ c: c,
+ d: d
+ };
+ warning.reason = warning.raw.supplant(warning);
+ JSLINT.errors.push(warning);
+ if (option.passfail) {
+ quit(bundle.stopping, line, character);
+ }
+ warnings += 1;
+ if (warnings >= option.maxerr) {
+ quit(bundle.too_many, line, character);
+ }
+ return warning;
+ }
+
+ function warn_at(message, line, character, a, b, c, d) {
+ return warn(message, {
+ line: line,
+ from: character
+ }, a, b, c, d);
+ }
+
+ function stop(message, offender, a, b, c, d) {
+ var warning = warn(message, offender, a, b, c, d);
+ quit(bundle.stopping, warning.line, warning.character);
+ }
+
+ function stop_at(message, line, character, a, b, c, d) {
+ return stop(message, {
+ line: line,
+ from: character
+ }, a, b, c, d);
+ }
+
+ function expected_at(at) {
+ if (!option.white && next_token.from !== at) {
+ warn('expected_a_at_b_c', next_token, '', at,
+ next_token.from);
+ }
+ }
+
+ function aint(it, name, expected) {
+ if (it[name] !== expected) {
+ warn('expected_a_b', it, expected, it[name]);
+ return true;
+ }
+ return false;
+ }
+
+
+// lexical analysis and token construction
+
+ lex = (function lex() {
+ var character, c, from, length, line, pos, source_row;
+
+// Private lex methods
+
+ function next_line() {
+ var at;
+ character = 1;
+ source_row = lines[line];
+ line += 1;
+ if (source_row === undefined) {
+ return false;
+ }
+ at = source_row.search(/\t/);
+ if (at >= 0) {
+ if (option.white) {
+ source_row = source_row.replace(/\t/g, ' ');
+ } else {
+ warn_at('use_spaces', line, at + 1);
+ }
+ }
+ at = source_row.search(cx);
+ if (at >= 0) {
+ warn_at('unsafe', line, at);
+ }
+ if (option.maxlen && option.maxlen < source_row.length) {
+ warn_at('too_long', line, source_row.length);
+ }
+ return true;
+ }
+
+// Produce a token object. The token inherits from a syntax symbol.
+
+ function it(type, value) {
+ var id, the_token;
+ if (type === '(string)' || type === '(range)') {
+ if (jx.test(value)) {
+ warn_at('url', line, from);
+ }
+ }
+ the_token = Object.create(syntax[(
+ type === '(punctuator)' || (type === '(identifier)' &&
+ Object.prototype.hasOwnProperty.call(syntax, value))
+ ? value
+ : type
+ )] || syntax['(error)']);
+ if (type === '(identifier)') {
+ the_token.identifier = true;
+ if (value === '__iterator__' || value === '__proto__') {
+ stop_at('reserved_a', line, from, value);
+ } else if (!option.nomen &&
+ (value.charAt(0) === '_' ||
+ value.charAt(value.length - 1) === '_')) {
+ warn_at('dangling_a', line, from, value);
+ }
+ }
+ if (type === '(number)') {
+ the_token.number = +value;
+ } else if (value !== undefined) {
+ the_token.string = String(value);
+ }
+ the_token.line = line;
+ the_token.from = from;
+ the_token.thru = character;
+ id = the_token.id;
+ prereg = id && (
+ ('(,=:[!&|?{};~+-*%^<>'.indexOf(id.charAt(id.length - 1)) >= 0) ||
+ id === 'return' || id === 'case'
+ );
+ return the_token;
+ }
+
+ function match(x) {
+ var exec = x.exec(source_row), first;
+ if (exec) {
+ length = exec[0].length;
+ first = exec[1];
+ c = first.charAt(0);
+ source_row = source_row.slice(length);
+ from = character + length - first.length;
+ character += length;
+ return first;
+ }
+ }
+
+ function string(x) {
+ var c, pos = 0, r = '', result;
+
+ function hex(n) {
+ var i = parseInt(source_row.substr(pos + 1, n), 16);
+ pos += n;
+ if (i >= 32 && i <= 126 &&
+ i !== 34 && i !== 92 && i !== 39) {
+ warn_at('unexpected_a', line, character, '\\');
+ }
+ character += n;
+ c = String.fromCharCode(i);
+ }
+
+ if (json_mode && x !== '"') {
+ warn_at('expected_a', line, character, '"');
+ }
+
+ if (xquote === x || (xmode === 'scriptstring' && !xquote)) {
+ return it('(punctuator)', x);
+ }
+
+ for (;;) {
+ while (pos >= source_row.length) {
+ pos = 0;
+ if (xmode !== 'html' || !next_line()) {
+ stop_at('unclosed', line, from);
+ }
+ }
+ c = source_row.charAt(pos);
+ if (c === x) {
+ character += 1;
+ source_row = source_row.slice(pos + 1);
+ result = it('(string)', r);
+ result.quote = x;
+ return result;
+ }
+ if (c < ' ') {
+ if (c === '\n' || c === '\r') {
+ break;
+ }
+ warn_at('control_a', line, character + pos,
+ source_row.slice(0, pos));
+ } else if (c === xquote) {
+ warn_at('bad_html', line, character + pos);
+ } else if (c === '<') {
+ if (option.safe && xmode === 'html') {
+ warn_at('adsafe_a', line, character + pos, c);
+ } else if (source_row.charAt(pos + 1) === '/' && (xmode || option.safe)) {
+ warn_at('expected_a_b', line, character,
+ '<\\/', '= '0' && c <= '7' ? 'octal_a' : 'unexpected_a',
+ line, character, '\\' + c);
+ } else {
+ c = descapes[c];
+ }
+ }
+ }
+ }
+ r += c;
+ character += 1;
+ pos += 1;
+ }
+ }
+
+ function number(snippet) {
+ var digit;
+ if (xmode !== 'style' && xmode !== 'styleproperty' &&
+ source_row.charAt(0).isAlpha()) {
+ warn_at('expected_space_a_b',
+ line, character, c, source_row.charAt(0));
+ }
+ if (c === '0') {
+ digit = snippet.charAt(1);
+ if (digit.isDigit()) {
+ if (token.id !== '.' && xmode !== 'styleproperty') {
+ warn_at('unexpected_a', line, character, snippet);
+ }
+ } else if (json_mode && (digit === 'x' || digit === 'X')) {
+ warn_at('unexpected_a', line, character, '0x');
+ }
+ }
+ if (snippet.slice(snippet.length - 1) === '.') {
+ warn_at('trailing_decimal_a', line, character, snippet);
+ }
+ if (xmode !== 'style') {
+ digit = +snippet;
+ if (!isFinite(digit)) {
+ warn_at('bad_number', line, character, snippet);
+ }
+ snippet = digit;
+ }
+ return it('(number)', snippet);
+ }
+
+ function comment(snippet) {
+ if (comments_off || src || (xmode && xmode !== 'script' &&
+ xmode !== 'style' && xmode !== 'styleproperty')) {
+ warn_at('unexpected_comment', line, character);
+ } else if (xmode === 'script' && /<\//i.test(source_row)) {
+ warn_at('unexpected_a', line, character, '<\/');
+ } else if (option.safe && ax.test(snippet)) {
+ warn_at('dangerous_comment', line, character);
+ } else if (!option.todo && tox.test(snippet)) {
+ warn_at('todo_comment', line, character);
+ }
+ }
+
+ function regexp() {
+ var b,
+ bit,
+ captures = 0,
+ depth = 0,
+ flag = '',
+ high,
+ letter,
+ length = 0,
+ low,
+ potential,
+ quote,
+ result;
+ for (;;) {
+ b = true;
+ c = source_row.charAt(length);
+ length += 1;
+ switch (c) {
+ case '':
+ stop_at('unclosed_regexp', line, from);
+ return;
+ case '/':
+ if (depth > 0) {
+ warn_at('unescaped_a', line, from + length, '/');
+ }
+ c = source_row.slice(0, length - 1);
+ potential = Object.create(regexp_flag);
+ for (;;) {
+ letter = source_row.charAt(length);
+ if (potential[letter] !== true) {
+ break;
+ }
+ potential[letter] = false;
+ length += 1;
+ flag += letter;
+ }
+ if (source_row.charAt(length).isAlpha()) {
+ stop_at('unexpected_a', line, from, source_row.charAt(length));
+ }
+ character += length;
+ source_row = source_row.slice(length);
+ quote = source_row.charAt(0);
+ if (quote === '/' || quote === '*') {
+ stop_at('confusing_regexp', line, from);
+ }
+ result = it('(regexp)', c);
+ result.flag = flag;
+ return result;
+ case '\\':
+ c = source_row.charAt(length);
+ if (c < ' ') {
+ warn_at('control_a', line, from + length, String(c));
+ } else if (c === '<') {
+ warn_at(bundle.unexpected_a, line, from + length, '\\');
+ }
+ length += 1;
+ break;
+ case '(':
+ depth += 1;
+ b = false;
+ if (source_row.charAt(length) === '?') {
+ length += 1;
+ switch (source_row.charAt(length)) {
+ case ':':
+ case '=':
+ case '!':
+ length += 1;
+ break;
+ default:
+ warn_at(bundle.expected_a_b, line, from + length,
+ ':', source_row.charAt(length));
+ }
+ } else {
+ captures += 1;
+ }
+ break;
+ case '|':
+ b = false;
+ break;
+ case ')':
+ if (depth === 0) {
+ warn_at('unescaped_a', line, from + length, ')');
+ } else {
+ depth -= 1;
+ }
+ break;
+ case ' ':
+ pos = 1;
+ while (source_row.charAt(length) === ' ') {
+ length += 1;
+ pos += 1;
+ }
+ if (pos > 1) {
+ warn_at('use_braces', line, from + length, pos);
+ }
+ break;
+ case '[':
+ c = source_row.charAt(length);
+ if (c === '^') {
+ length += 1;
+ if (!option.regexp) {
+ warn_at('insecure_a', line, from + length, c);
+ } else if (source_row.charAt(length) === ']') {
+ stop_at('unescaped_a', line, from + length, '^');
+ }
+ }
+ bit = false;
+ if (c === ']') {
+ warn_at('empty_class', line, from + length - 1);
+ bit = true;
+ }
+klass: do {
+ c = source_row.charAt(length);
+ length += 1;
+ switch (c) {
+ case '[':
+ case '^':
+ warn_at('unescaped_a', line, from + length, c);
+ bit = true;
+ break;
+ case '-':
+ if (bit) {
+ bit = false;
+ } else {
+ warn_at('unescaped_a', line, from + length, '-');
+ bit = true;
+ }
+ break;
+ case ']':
+ if (!bit) {
+ warn_at('unescaped_a', line, from + length - 1, '-');
+ }
+ break klass;
+ case '\\':
+ c = source_row.charAt(length);
+ if (c < ' ') {
+ warn_at(bundle.control_a, line, from + length, String(c));
+ } else if (c === '<') {
+ warn_at(bundle.unexpected_a, line, from + length, '\\');
+ }
+ length += 1;
+ bit = true;
+ break;
+ case '/':
+ warn_at('unescaped_a', line, from + length - 1, '/');
+ bit = true;
+ break;
+ case '<':
+ if (xmode === 'script') {
+ c = source_row.charAt(length);
+ if (c === '!' || c === '/') {
+ warn_at(bundle.html_confusion_a, line,
+ from + length, c);
+ }
+ }
+ bit = true;
+ break;
+ default:
+ bit = true;
+ }
+ } while (c);
+ break;
+ case '.':
+ if (!option.regexp) {
+ warn_at('insecure_a', line, from + length, c);
+ }
+ break;
+ case ']':
+ case '?':
+ case '{':
+ case '}':
+ case '+':
+ case '*':
+ warn_at('unescaped_a', line, from + length, c);
+ break;
+ case '<':
+ if (xmode === 'script') {
+ c = source_row.charAt(length);
+ if (c === '!' || c === '/') {
+ warn_at(bundle.html_confusion_a, line, from + length, c);
+ }
+ }
+ break;
+ }
+ if (b) {
+ switch (source_row.charAt(length)) {
+ case '?':
+ case '+':
+ case '*':
+ length += 1;
+ if (source_row.charAt(length) === '?') {
+ length += 1;
+ }
+ break;
+ case '{':
+ length += 1;
+ c = source_row.charAt(length);
+ if (c < '0' || c > '9') {
+ warn_at(bundle.expected_number_a, line,
+ from + length, c);
+ }
+ length += 1;
+ low = +c;
+ for (;;) {
+ c = source_row.charAt(length);
+ if (c < '0' || c > '9') {
+ break;
+ }
+ length += 1;
+ low = +c + (low * 10);
+ }
+ high = low;
+ if (c === ',') {
+ length += 1;
+ high = Infinity;
+ c = source_row.charAt(length);
+ if (c >= '0' && c <= '9') {
+ length += 1;
+ high = +c;
+ for (;;) {
+ c = source_row.charAt(length);
+ if (c < '0' || c > '9') {
+ break;
+ }
+ length += 1;
+ high = +c + (high * 10);
+ }
+ }
+ }
+ if (source_row.charAt(length) !== '}') {
+ warn_at(bundle.expected_a_b, line, from + length,
+ '}', c);
+ } else {
+ length += 1;
+ }
+ if (source_row.charAt(length) === '?') {
+ length += 1;
+ }
+ if (low > high) {
+ warn_at(bundle.not_greater, line, from + length,
+ low, high);
+ }
+ break;
+ }
+ }
+ }
+ c = source_row.slice(0, length - 1);
+ character += length;
+ source_row = source_row.slice(length);
+ return it('(regexp)', c);
+ }
+
+// Public lex methods
+
+ return {
+ init: function (source) {
+ if (typeof source === 'string') {
+ lines = source.split(crlfx);
+ } else {
+ lines = source;
+ }
+ line = 0;
+ next_line();
+ from = 1;
+ },
+
+ range: function (begin, end) {
+ var c, value = '';
+ from = character;
+ if (source_row.charAt(0) !== begin) {
+ stop_at('expected_a_b', line, character, begin,
+ source_row.charAt(0));
+ }
+ for (;;) {
+ source_row = source_row.slice(1);
+ character += 1;
+ c = source_row.charAt(0);
+ switch (c) {
+ case '':
+ stop_at('missing_a', line, character, c);
+ break;
+ case end:
+ source_row = source_row.slice(1);
+ character += 1;
+ return it('(range)', value);
+ case xquote:
+ case '\\':
+ warn_at('unexpected_a', line, character, c);
+ break;
+ }
+ value += c;
+ }
+ },
+
+// token -- this is called by advance to get the next token.
+
+ token: function () {
+ var c, i, snippet;
+
+ for (;;) {
+ while (!source_row) {
+ if (!next_line()) {
+ return it('(end)');
+ }
+ }
+ while (xmode === 'outer') {
+ i = source_row.search(ox);
+ if (i === 0) {
+ break;
+ } else if (i > 0) {
+ character += i;
+ source_row = source_row.slice(i);
+ break;
+ } else {
+ if (!next_line()) {
+ return it('(end)', '');
+ }
+ }
+ }
+ snippet = match(rx[xmode] || tx);
+ if (!snippet) {
+ if (source_row) {
+ if (source_row.charAt(0) === ' ') {
+ if (!option.white) {
+ warn_at('unexpected_a', line, character,
+ '(space)');
+ }
+ character += 1;
+ source_row = '';
+ } else {
+ stop_at('unexpected_a', line, character,
+ source_row.charAt(0));
+ }
+ }
+ } else {
+
+// identifier
+
+ c = snippet.charAt(0);
+ if (c.isAlpha() || c === '_' || c === '$') {
+ return it('(identifier)', snippet);
+ }
+
+// number
+
+ if (c.isDigit()) {
+ return number(snippet);
+ }
+ switch (snippet) {
+
+// string
+
+ case '"':
+ case "'":
+ return string(snippet);
+
+// // comment
+
+ case '//':
+ comment(source_row);
+ source_row = '';
+ break;
+
+// /* comment
+
+ case '/*':
+ for (;;) {
+ i = source_row.search(lx);
+ if (i >= 0) {
+ break;
+ }
+ comment(source_row);
+ if (!next_line()) {
+ stop_at('unclosed_comment', line, character);
+ }
+ }
+ comment(source_row.slice(0, i));
+ character += i + 2;
+ if (source_row.charAt(i) === '/') {
+ stop_at('nested_comment', line, character);
+ }
+ source_row = source_row.slice(i + 2);
+ break;
+
+ case '':
+ break;
+// /
+ case '/':
+ if (token.id === '/=') {
+ stop_at(
+ bundle.slash_equal,
+ line,
+ from
+ );
+ }
+ return prereg
+ ? regexp()
+ : it('(punctuator)', snippet);
+
+// punctuator
+
+ case '');
+ }
+ character += 3;
+ source_row = source_row.slice(i + 3);
+ break;
+ case '#':
+ if (xmode === 'html' || xmode === 'styleproperty') {
+ for (;;) {
+ c = source_row.charAt(0);
+ if ((c < '0' || c > '9') &&
+ (c < 'a' || c > 'f') &&
+ (c < 'A' || c > 'F')) {
+ break;
+ }
+ character += 1;
+ source_row = source_row.slice(1);
+ snippet += c;
+ }
+ if (snippet.length !== 4 && snippet.length !== 7) {
+ warn_at('bad_color_a', line,
+ from + length, snippet);
+ }
+ return it('(color)', snippet);
+ }
+ return it('(punctuator)', snippet);
+
+ default:
+ if (xmode === 'outer' && c === '&') {
+ character += 1;
+ source_row = source_row.slice(1);
+ for (;;) {
+ c = source_row.charAt(0);
+ character += 1;
+ source_row = source_row.slice(1);
+ if (c === ';') {
+ break;
+ }
+ if (!((c >= '0' && c <= '9') ||
+ (c >= 'a' && c <= 'z') ||
+ c === '#')) {
+ stop_at('bad_entity', line, from + length,
+ character);
+ }
+ }
+ break;
+ }
+ return it('(punctuator)', snippet);
+ }
+ }
+ }
+ }
+ };
+ }());
+
+
+ function add_label(token, kind, name) {
+
+// Define the symbol in the current function in the current scope.
+
+ name = name || token.string;
+
+// Global variables cannot be created in the safe subset. If a global variable
+// already exists, do nothing. If it is predefined, define it.
+
+ if (funct === global_funct) {
+ if (option.safe) {
+ warn('adsafe_a', token, name);
+ }
+ if (typeof global_funct[name] !== 'string') {
+ token.writeable = typeof predefined[name] === 'boolean'
+ ? predefined[name]
+ : true;
+ global_scope[name] = token;
+ }
+ if (kind === 'becoming') {
+ kind = 'var';
+ }
+
+// Ordinary variables.
+
+ } else {
+
+// Warn if the variable already exists.
+
+ if (typeof funct[name] === 'string') {
+ if (funct[name] === 'undef') {
+ if (!option.undef) {
+ warn('used_before_a', token, name);
+ }
+ kind = 'var';
+ } else {
+ warn('already_defined', token, name);
+ }
+ } else {
+
+// Add the symbol to the current function.
+
+ token.writeable = true;
+ scope[name] = token;
+ }
+ }
+ token.function = funct;
+ funct[name] = kind;
+ }
+
+
+ function peek(distance) {
+
+// Peek ahead to a future token. The distance is how far ahead to look. The
+// default is the next token.
+
+ var found, slot = 0;
+
+ distance = distance || 0;
+ while (slot <= distance) {
+ found = lookahead[slot];
+ if (!found) {
+ found = lookahead[slot] = lex.token();
+ }
+ slot += 1;
+ }
+ return found;
+ }
+
+
+ function advance(id, match) {
+
+// Produce the next token, also looking for programming errors.
+
+ if (indent) {
+
+// If indentation checking was requested, then inspect all of the line breakings.
+// The var statement is tricky because the names might be aligned or not. We
+// look at the first line break after the var to determine the programmer's
+// intention.
+
+ if (var_mode && next_token.line !== token.line) {
+ if ((var_mode !== indent || !next_token.edge) &&
+ next_token.from === indent.at -
+ (next_token.edge ? option.indent : 0)) {
+ var dent = indent;
+ for (;;) {
+ dent.at -= option.indent;
+ if (dent === var_mode) {
+ break;
+ }
+ dent = dent.was;
+ }
+ dent.open = false;
+ }
+ var_mode = null;
+ }
+ if (next_token.id === '?' && indent.mode === ':' &&
+ token.line !== next_token.line) {
+ indent.at -= option.indent;
+ }
+ if (indent.open) {
+
+// If the token is an edge.
+
+ if (next_token.edge) {
+ if (next_token.edge === 'label') {
+ expected_at(1);
+ } else if (next_token.edge === 'case' || indent.mode === 'statement') {
+ expected_at(indent.at - option.indent);
+ } else if (indent.mode !== 'array' || next_token.line !== token.line) {
+ expected_at(indent.at);
+ }
+
+// If the token is not an edge, but is the first token on the line.
+
+ } else if (next_token.line !== token.line) {
+ if (next_token.from < indent.at + (indent.mode ===
+ 'expression' ? 0 : option.indent)) {
+ expected_at(indent.at + option.indent);
+ }
+ indent.wrap = true;
+ }
+ } else if (next_token.line !== token.line) {
+ if (next_token.edge) {
+ expected_at(indent.at);
+ } else {
+ indent.wrap = true;
+ if (indent.mode === 'statement' || indent.mode === 'var') {
+ expected_at(indent.at + option.indent);
+ } else if (next_token.from < indent.at + (indent.mode ===
+ 'expression' ? 0 : option.indent)) {
+ expected_at(indent.at + option.indent);
+ }
+ }
+ }
+ }
+
+ switch (token.id) {
+ case '(number)':
+ if (next_token.id === '.') {
+ warn('trailing_decimal_a');
+ }
+ break;
+ case '-':
+ if (next_token.id === '-' || next_token.id === '--') {
+ warn('confusing_a');
+ }
+ break;
+ case '+':
+ if (next_token.id === '+' || next_token.id === '++') {
+ warn('confusing_a');
+ }
+ break;
+ }
+ if (token.id === '(string)' || token.identifier) {
+ anonname = token.string;
+ }
+
+ if (id && next_token.id !== id) {
+ if (match) {
+ warn('expected_a_b_from_c_d', next_token, id,
+ match.id, match.line, artifact());
+ } else if (!next_token.identifier || next_token.string !== id) {
+ warn('expected_a_b', next_token, id, artifact());
+ }
+ }
+ prev_token = token;
+ token = next_token;
+ next_token = lookahead.shift() || lex.token();
+ next_token.function = funct;
+ tokens.push(next_token);
+ }
+
+
+ function advance_identifier(string) {
+ if (next_token.identifier && next_token.string === string) {
+ advance();
+ } else {
+ warn('expected_a_b', next_token, string, artifact());
+ }
+ }
+
+
+ function do_safe() {
+ if (option.adsafe) {
+ option.safe = true;
+ }
+ if (option.safe) {
+ option.browser =
+ option.continue =
+ option.css =
+ option.debug =
+ option.devel =
+ option.evil =
+ option.forin =
+ option.newcap =
+ option.nomen =
+ option.on =
+ option.rhino =
+ option.sloppy =
+ option.sub =
+ option.undef =
+ option.windows = false;
+
+
+ delete predefined.Array;
+ delete predefined.Date;
+ delete predefined.Function;
+ delete predefined.Object;
+ delete predefined.eval;
+
+ add_to_predefined({
+ ADSAFE: false,
+ lib: false
+ });
+ }
+ }
+
+
+ function do_globals() {
+ var name, writeable;
+ for (;;) {
+ if (next_token.id !== '(string)' && !next_token.identifier) {
+ return;
+ }
+ name = next_token.string;
+ advance();
+ writeable = false;
+ if (next_token.id === ':') {
+ advance(':');
+ switch (next_token.id) {
+ case 'true':
+ writeable = predefined[name] !== false;
+ advance('true');
+ break;
+ case 'false':
+ advance('false');
+ break;
+ default:
+ stop('unexpected_a');
+ }
+ }
+ predefined[name] = writeable;
+ if (next_token.id !== ',') {
+ return;
+ }
+ advance(',');
+ }
+ }
+
+
+ function do_jslint() {
+ var name, value;
+ while (next_token.id === '(string)' || next_token.identifier) {
+ name = next_token.string;
+ if (!allowed_option[name]) {
+ stop('unexpected_a');
+ }
+ advance();
+ if (next_token.id !== ':') {
+ stop('expected_a_b', next_token, ':', artifact());
+ }
+ advance(':');
+ if (typeof allowed_option[name] === 'number') {
+ value = next_token.number;
+ if (value > allowed_option[name] || value <= 0 ||
+ Math.floor(value) !== value) {
+ stop('expected_small_a');
+ }
+ option[name] = value;
+ } else {
+ if (next_token.id === 'true') {
+ option[name] = true;
+ } else if (next_token.id === 'false') {
+ option[name] = false;
+ } else {
+ stop('unexpected_a');
+ }
+ }
+ advance();
+ if (next_token.id === ',') {
+ advance(',');
+ }
+ }
+ assume();
+ }
+
+
+ function do_properties() {
+ var name;
+ option.properties = true;
+ for (;;) {
+ if (next_token.id !== '(string)' && !next_token.identifier) {
+ return;
+ }
+ name = next_token.string;
+ advance();
+ if (next_token.id === ':') {
+ for (;;) {
+ advance();
+ if (next_token.id !== '(string)' && !next_token.identifier) {
+ break;
+ }
+ }
+ }
+ property[name] = 0;
+ if (next_token.id !== ',') {
+ return;
+ }
+ advance(',');
+ }
+ }
+
+
+ directive = function directive() {
+ var command = this.id,
+ old_comments_off = comments_off,
+ old_indent = indent;
+ comments_off = true;
+ indent = null;
+ if (next_token.line === token.line && next_token.from === token.thru) {
+ warn('missing_space_a_b', next_token, artifact(token), artifact());
+ }
+ if (lookahead.length > 0) {
+ warn('unexpected_a', this);
+ }
+ switch (command) {
+ case '/*properties':
+ case '/*property':
+ case '/*members':
+ case '/*member':
+ do_properties();
+ break;
+ case '/*jslint':
+ if (option.safe) {
+ warn('adsafe_a', this);
+ }
+ do_jslint();
+ break;
+ case '/*globals':
+ case '/*global':
+ if (option.safe) {
+ warn('adsafe_a', this);
+ }
+ do_globals();
+ break;
+ default:
+ stop('unexpected_a', this);
+ }
+ comments_off = old_comments_off;
+ advance('*/');
+ indent = old_indent;
+ };
+
+
+// Indentation intention
+
+ function edge(mode) {
+ next_token.edge = indent ? indent.open && (mode || 'edge') : '';
+ }
+
+
+ function step_in(mode) {
+ var open;
+ if (typeof mode === 'number') {
+ indent = {
+ at: +mode,
+ open: true,
+ was: indent
+ };
+ } else if (!indent) {
+ indent = {
+ at: 1,
+ mode: 'statement',
+ open: true
+ };
+ } else if (mode === 'statement') {
+ indent = {
+ at: indent.at,
+ open: true,
+ was: indent
+ };
+ } else {
+ open = mode === 'var' || next_token.line !== token.line;
+ indent = {
+ at: (open || mode === 'control'
+ ? indent.at + option.indent
+ : indent.at) + (indent.wrap ? option.indent : 0),
+ mode: mode,
+ open: open,
+ was: indent
+ };
+ if (mode === 'var' && open) {
+ var_mode = indent;
+ }
+ }
+ }
+
+ function step_out(id, symbol) {
+ if (id) {
+ if (indent && indent.open) {
+ indent.at -= option.indent;
+ edge();
+ }
+ advance(id, symbol);
+ }
+ if (indent) {
+ indent = indent.was;
+ }
+ }
+
+// Functions for conformance of whitespace.
+
+ function one_space(left, right) {
+ left = left || token;
+ right = right || next_token;
+ if (right.id !== '(end)' && !option.white &&
+ (token.line !== right.line ||
+ token.thru + 1 !== right.from)) {
+ warn('expected_space_a_b', right, artifact(token), artifact(right));
+ }
+ }
+
+ function one_space_only(left, right) {
+ left = left || token;
+ right = right || next_token;
+ if (right.id !== '(end)' && (left.line !== right.line ||
+ (!option.white && left.thru + 1 !== right.from))) {
+ warn('expected_space_a_b', right, artifact(left), artifact(right));
+ }
+ }
+
+ function no_space(left, right) {
+ left = left || token;
+ right = right || next_token;
+ if ((!option.white || xmode === 'styleproperty' || xmode === 'style') &&
+ left.thru !== right.from && left.line === right.line) {
+ warn('unexpected_space_a_b', right, artifact(left), artifact(right));
+ }
+ }
+
+ function no_space_only(left, right) {
+ left = left || token;
+ right = right || next_token;
+ if (right.id !== '(end)' && (left.line !== right.line ||
+ (!option.white && left.thru !== right.from))) {
+ warn('unexpected_space_a_b', right, artifact(left), artifact(right));
+ }
+ }
+
+ function spaces(left, right) {
+ if (!option.white) {
+ left = left || token;
+ right = right || next_token;
+ if (left.thru === right.from && left.line === right.line) {
+ warn('missing_space_a_b', right, artifact(left), artifact(right));
+ }
+ }
+ }
+
+ function comma() {
+ if (next_token.id !== ',') {
+ warn_at('expected_a_b', token.line, token.thru, ',', artifact());
+ } else {
+ if (!option.white) {
+ no_space_only();
+ }
+ advance(',');
+ spaces();
+ }
+ }
+
+
+ function semicolon() {
+ if (next_token.id !== ';') {
+ warn_at('expected_a_b', token.line, token.thru, ';', artifact());
+ } else {
+ if (!option.white) {
+ no_space_only();
+ }
+ advance(';');
+ if (semicolon_coda[next_token.id] !== true) {
+ spaces();
+ }
+ }
+ }
+
+ function use_strict() {
+ if (next_token.string === 'use strict') {
+ if (strict_mode) {
+ warn('unnecessary_use');
+ }
+ edge();
+ advance();
+ semicolon();
+ strict_mode = true;
+ option.undef = false;
+ return true;
+ }
+ return false;
+ }
+
+
+ function are_similar(a, b) {
+ if (a === b) {
+ return true;
+ }
+ if (Array.isArray(a)) {
+ if (Array.isArray(b) && a.length === b.length) {
+ var i;
+ for (i = 0; i < a.length; i += 1) {
+ if (!are_similar(a[i], b[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+ if (Array.isArray(b)) {
+ return false;
+ }
+ if (a.id === '(number)' && b.id === '(number)') {
+ return a.number === b.number;
+ }
+ if (a.arity === b.arity && a.string === b.string) {
+ switch (a.arity) {
+ case 'prefix':
+ case 'suffix':
+ case undefined:
+ return a.id === b.id && are_similar(a.first, b.first) &&
+ a.id !== '{' && a.id !== '[';
+ case 'infix':
+ return are_similar(a.first, b.first) &&
+ are_similar(a.second, b.second);
+ case 'ternary':
+ return are_similar(a.first, b.first) &&
+ are_similar(a.second, b.second) &&
+ are_similar(a.third, b.third);
+ case 'function':
+ case 'regexp':
+ return false;
+ default:
+ return true;
+ }
+ } else {
+ if (a.id === '.' && b.id === '[' && b.arity === 'infix') {
+ return a.second.string === b.second.string && b.second.id === '(string)';
+ }
+ if (a.id === '[' && a.arity === 'infix' && b.id === '.') {
+ return a.second.string === b.second.string && a.second.id === '(string)';
+ }
+ }
+ return false;
+ }
+
+
+// This is the heart of JSLINT, the Pratt parser. In addition to parsing, it
+// is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
+// like .nud except that it is only used on the first token of a statement.
+// Having .fud makes it much easier to define statement-oriented languages like
+// JavaScript. I retained Pratt's nomenclature.
+
+// .nud Null denotation
+// .fud First null denotation
+// .led Left denotation
+// lbp Left binding power
+// rbp Right binding power
+
+// They are elements of the parsing method called Top Down Operator Precedence.
+
+ function expression(rbp, initial) {
+
+// rbp is the right binding power.
+// initial indicates that this is the first expression of a statement.
+
+ var left;
+ if (next_token.id === '(end)') {
+ stop('unexpected_a', token, next_token.id);
+ }
+ advance();
+ if (option.safe && scope[token.string] &&
+ scope[token.string] === global_scope[token.string] &&
+ (next_token.id !== '(' && next_token.id !== '.')) {
+ warn('adsafe_a', token);
+ }
+ if (initial) {
+ anonname = 'anonymous';
+ funct['(verb)'] = token.string;
+ }
+ if (initial === true && token.fud) {
+ left = token.fud();
+ } else {
+ if (token.nud) {
+ left = token.nud();
+ } else {
+ if (next_token.id === '(number)' && token.id === '.') {
+ warn('leading_decimal_a', token, artifact());
+ advance();
+ return token;
+ }
+ stop('expected_identifier_a', token, token.id);
+ }
+ while (rbp < next_token.lbp) {
+ advance();
+ if (token.led) {
+ left = token.led(left);
+ } else {
+ stop('expected_operator_a', token, token.id);
+ }
+ }
+ }
+ return left;
+ }
+
+
+// Functional constructors for making the symbols that will be inherited by
+// tokens.
+
+ function symbol(s, p) {
+ var x = syntax[s];
+ if (!x || typeof x !== 'object') {
+ syntax[s] = x = {
+ id: s,
+ lbp: p || 0,
+ string: s
+ };
+ }
+ return x;
+ }
+
+ function postscript(x) {
+ x.postscript = true;
+ return x;
+ }
+
+ function ultimate(s) {
+ var x = symbol(s, 0);
+ x.from = 1;
+ x.thru = 1;
+ x.line = 0;
+ x.edge = 'edge';
+ x.string = s;
+ return postscript(x);
+ }
+
+
+ function stmt(s, f) {
+ var x = symbol(s);
+ x.identifier = x.reserved = true;
+ x.fud = f;
+ return x;
+ }
+
+ function labeled_stmt(s, f) {
+ var x = stmt(s, f);
+ x.labeled = true;
+ }
+
+ function disrupt_stmt(s, f) {
+ var x = stmt(s, f);
+ x.disrupt = true;
+ }
+
+
+ function reserve_name(x) {
+ var c = x.id.charAt(0);
+ if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
+ x.identifier = x.reserved = true;
+ }
+ return x;
+ }
+
+
+ function prefix(s, f) {
+ var x = symbol(s, 150);
+ reserve_name(x);
+ x.nud = function () {
+ var that = this;
+ that.arity = 'prefix';
+ if (typeof f === 'function') {
+ that = f(that);
+ if (that.arity !== 'prefix') {
+ return that;
+ }
+ } else {
+ if (s === 'typeof') {
+ one_space();
+ } else {
+ no_space_only();
+ }
+ that.first = expression(150);
+ }
+ switch (that.id) {
+ case '++':
+ case '--':
+ if (!option.plusplus) {
+ warn('unexpected_a', that);
+ } else if ((!that.first.identifier || that.first.reserved) &&
+ that.first.id !== '.' && that.first.id !== '[') {
+ warn('bad_operand', that);
+ }
+ break;
+ default:
+ if (that.first.arity === 'prefix' ||
+ that.first.arity === 'function') {
+ warn('unexpected_a', that);
+ }
+ }
+ return that;
+ };
+ return x;
+ }
+
+
+ function type(s, t, nud) {
+ var x = symbol(s);
+ x.arity = t;
+ if (nud) {
+ x.nud = nud;
+ }
+ return x;
+ }
+
+
+ function reserve(s, f) {
+ var x = symbol(s);
+ x.identifier = x.reserved = true;
+ if (typeof f === 'function') {
+ x.nud = f;
+ }
+ return x;
+ }
+
+
+ function constant(name) {
+ var x = reserve(name);
+ x.string = name;
+ x.nud = return_this;
+ return x;
+ }
+
+
+ function reservevar(s, v) {
+ return reserve(s, function () {
+ if (typeof v === 'function') {
+ v(this);
+ }
+ return this;
+ });
+ }
+
+
+ function infix(s, p, f, w) {
+ var x = symbol(s, p);
+ reserve_name(x);
+ x.led = function (left) {
+ this.arity = 'infix';
+ if (!w) {
+ spaces(prev_token, token);
+ spaces();
+ }
+ if (!option.bitwise && this.bitwise) {
+ warn('unexpected_a', this);
+ }
+ if (typeof f === 'function') {
+ return f(left, this);
+ }
+ this.first = left;
+ this.second = expression(p);
+ return this;
+ };
+ return x;
+ }
+
+ function expected_relation(node, message) {
+ if (node.assign) {
+ warn(message || bundle.conditional_assignment, node);
+ }
+ return node;
+ }
+
+ function expected_condition(node, message) {
+ switch (node.id) {
+ case '[':
+ case '-':
+ if (node.arity !== 'infix') {
+ warn(message || bundle.weird_condition, node);
+ }
+ break;
+ case 'false':
+ case 'function':
+ case 'Infinity':
+ case 'NaN':
+ case 'null':
+ case 'true':
+ case 'undefined':
+ case 'void':
+ case '(number)':
+ case '(regexp)':
+ case '(string)':
+ case '{':
+ case '?':
+ case '~':
+ warn(message || bundle.weird_condition, node);
+ break;
+ case '(':
+ if (node.first.id === 'new' ||
+ (node.first.string === 'Boolean') ||
+ (node.first.id === '.' &&
+ numbery[node.first.second.string] === true)) {
+ warn(message || bundle.weird_condition, node);
+ }
+ break;
+ }
+ return node;
+ }
+
+ function check_relation(node) {
+ switch (node.arity) {
+ case 'prefix':
+ switch (node.id) {
+ case '{':
+ case '[':
+ warn('unexpected_a', node);
+ break;
+ case '!':
+ warn('confusing_a', node);
+ break;
+ }
+ break;
+ case 'function':
+ case 'regexp':
+ warn('unexpected_a', node);
+ break;
+ default:
+ if (node.id === 'NaN') {
+ warn('isNaN', node);
+ }
+ }
+ return node;
+ }
+
+
+ function relation(s, eqeq) {
+ return infix(s, 100, function (left, that) {
+ check_relation(left);
+ if (eqeq && !option.eqeq) {
+ warn('expected_a_b', that, eqeq, that.id);
+ }
+ var right = expression(100);
+ if (are_similar(left, right) ||
+ ((left.id === '(string)' || left.id === '(number)') &&
+ (right.id === '(string)' || right.id === '(number)'))) {
+ warn('weird_relation', that);
+ } else if (left.id === 'typeof') {
+ if (right.id !== '(string)') {
+ warn("expected_string_a", right, right.id === '(number)'
+ ? right.number
+ : right.string);
+ } else if (right.string === 'undefined' ||
+ right.string === 'null') {
+ warn("unexpected_typeof_a", left, right.string);
+ }
+ } else if (right.id === 'typeof') {
+ if (left.id !== '(string)') {
+ warn("expected_string_a", left, left.id === '(number)'
+ ? left.number
+ : left.string);
+ } else if (left.string === 'undefined' ||
+ left.string === 'null') {
+ warn("unexpected_typeof_a", right, left.string);
+ }
+ }
+ that.first = left;
+ that.second = check_relation(right);
+ return that;
+ });
+ }
+
+
+ function assignop(s, op) {
+ var x = infix(s, 20, function (left, that) {
+ var l;
+ that.first = left;
+ if (left.identifier) {
+ if (scope[left.string]) {
+ if (scope[left.string].writeable === false) {
+ warn('read_only', left);
+ }
+ } else {
+ stop('read_only');
+ }
+ if (funct['(params)']) {
+ funct['(params)'].forEach(function (value) {
+ if (value.string === left.string) {
+ value.assign = true;
+ }
+ });
+ }
+ } else if (option.safe) {
+ l = left;
+ do {
+ if (typeof predefined[l.string] === 'boolean') {
+ warn('adsafe_a', l);
+ }
+ l = l.first;
+ } while (l);
+ }
+ if (left === syntax.function) {
+ warn('identifier_function', token);
+ }
+ if (left.id === '.' || left.id === '[') {
+ if (!left.first || left.first.string === 'arguments') {
+ warn('bad_assignment', that);
+ }
+ } else if (left.identifier) {
+ if (!left.reserved && funct[left.string] === 'exception') {
+ warn('assign_exception', left);
+ }
+ } else {
+ warn('bad_assignment', that);
+ }
+ that.second = expression(19);
+ if (that.id === '=' && are_similar(that.first, that.second)) {
+ warn('weird_assignment', that);
+ }
+ return that;
+ });
+ x.assign = true;
+ if (op) {
+ if (syntax[op].bitwise) {
+ x.bitwise = true;
+ }
+ }
+ return x;
+ }
+
+
+ function bitwise(s, p) {
+ var x = infix(s, p, 'number');
+ x.bitwise = true;
+ return x;
+ }
+
+
+ function suffix(s) {
+ var x = symbol(s, 150);
+ x.led = function (left) {
+ no_space_only(prev_token, token);
+ if (!option.plusplus) {
+ warn('unexpected_a', this);
+ } else if ((!left.identifier || left.reserved) &&
+ left.id !== '.' && left.id !== '[') {
+ warn('bad_operand', this);
+ }
+ this.first = left;
+ this.arity = 'suffix';
+ return this;
+ };
+ return x;
+ }
+
+
+ function optional_identifier(variable) {
+ if (next_token.identifier) {
+ advance();
+ if (option.safe && banned[token.string]) {
+ warn('adsafe_a', token);
+ } else if (token.reserved && (!option.es5 || variable)) {
+ warn('expected_identifier_a_reserved', token);
+ }
+ return token.string;
+ }
+ }
+
+
+ function identifier(variable) {
+ var i = optional_identifier(variable);
+ if (!i) {
+ stop(token.id === 'function' && next_token.id === '('
+ ? 'name_function'
+ : 'expected_identifier_a');
+ }
+ return i;
+ }
+
+
+ function statement() {
+
+ var label, old_scope = scope, the_statement;
+
+// We don't like the empty statement.
+
+ if (next_token.id === ';') {
+ warn('unexpected_a');
+ semicolon();
+ return;
+ }
+
+// Is this a labeled statement?
+
+ if (next_token.identifier && !next_token.reserved && peek().id === ':') {
+ edge('label');
+ label = next_token;
+ advance();
+ advance(':');
+ scope = Object.create(old_scope);
+ add_label(label, 'label');
+ if (next_token.labeled !== true || funct === global_funct) {
+ stop('unexpected_label_a', label);
+ } else if (jx.test(label.string + ':')) {
+ warn('url', label);
+ }
+ next_token.label = label;
+ }
+
+// Parse the statement.
+
+ if (token.id !== 'else') {
+ edge();
+ }
+ step_in('statement');
+ the_statement = expression(0, true);
+ if (the_statement) {
+
+// Look for the final semicolon.
+
+ if (the_statement.arity === 'statement') {
+ if (the_statement.id === 'switch' ||
+ (the_statement.block && the_statement.id !== 'do')) {
+ spaces();
+ } else {
+ semicolon();
+ }
+ } else {
+
+// If this is an expression statement, determine if it is acceptable.
+// We do not like
+// new Blah;
+// statements. If it is to be used at all, new should only be used to make
+// objects, not side effects. The expression statements we do like do
+// assignment or invocation or delete.
+
+ if (the_statement.id === '(') {
+ if (the_statement.first.id === 'new') {
+ warn('bad_new');
+ }
+ } else if (!the_statement.assign &&
+ the_statement.id !== 'delete' &&
+ the_statement.id !== '++' &&
+ the_statement.id !== '--') {
+ warn('assignment_function_expression', the_statement);
+ }
+ semicolon();
+ }
+ }
+ step_out();
+ scope = old_scope;
+ return the_statement;
+ }
+
+
+ function statements() {
+ var array = [], disruptor, the_statement;
+
+// A disrupt statement may not be followed by any other statement.
+// If the last statement is disrupt, then the sequence is disrupt.
+
+ while (next_token.postscript !== true) {
+ if (next_token.id === ';') {
+ warn('unexpected_a', next_token);
+ semicolon();
+ } else {
+ if (next_token.string === 'use strict') {
+ if ((!node_js && xmode !== 'script') || funct !== global_funct || array.length > 0) {
+ warn('function_strict');
+ }
+ use_strict();
+ }
+ if (disruptor) {
+ warn('unreachable_a_b', next_token, next_token.string,
+ disruptor.string);
+ disruptor = null;
+ }
+ the_statement = statement();
+ if (the_statement) {
+ array.push(the_statement);
+ if (the_statement.disrupt) {
+ disruptor = the_statement;
+ array.disrupt = true;
+ }
+ }
+ }
+ }
+ return array;
+ }
+
+
+ function block(ordinary) {
+
+// array block is array sequence of statements wrapped in braces.
+// ordinary is false for function bodies and try blocks.
+// ordinary is true for if statements, while, etc.
+
+ var array,
+ curly = next_token,
+ old_in_block = in_block,
+ old_scope = scope,
+ old_strict_mode = strict_mode;
+
+ in_block = ordinary;
+ scope = Object.create(scope);
+ spaces();
+ if (next_token.id === '{') {
+ advance('{');
+ step_in();
+ if (!ordinary && !use_strict() && !old_strict_mode &&
+ !option.sloppy && funct['(context)'] === global_funct) {
+ warn('missing_use_strict');
+ }
+ array = statements();
+ strict_mode = old_strict_mode;
+ step_out('}', curly);
+ } else if (!ordinary) {
+ stop('expected_a_b', next_token, '{', artifact());
+ } else {
+ warn('expected_a_b', next_token, '{', artifact());
+ array = [statement()];
+ array.disrupt = array[0].disrupt;
+ }
+ funct['(verb)'] = null;
+ scope = old_scope;
+ in_block = old_in_block;
+ if (ordinary && array.length === 0) {
+ warn('empty_block');
+ }
+ return array;
+ }
+
+
+ function tally_property(name) {
+ if (option.properties && typeof property[name] !== 'number') {
+ warn('unexpected_property_a', token, name);
+ }
+ if (typeof property[name] === 'number') {
+ property[name] += 1;
+ } else {
+ property[name] = 1;
+ }
+ }
+
+
+// ECMAScript parser
+
+ syntax['(identifier)'] = {
+ id: '(identifier)',
+ lbp: 0,
+ identifier: true,
+ nud: function () {
+ var name = this.string,
+ variable = scope[name],
+ site,
+ writeable;
+
+// If the variable is not in scope, then we may have an undeclared variable.
+// Check the predefined list. If it was predefined, create the global
+// variable.
+
+ if (typeof variable !== 'object') {
+ writeable = predefined[name];
+ if (typeof writeable === 'boolean') {
+ global_scope[name] = variable = {
+ string: name,
+ writeable: writeable,
+ function: global_funct
+ };
+ global_funct[name] = 'var';
+
+// But if the variable is not in scope, and is not predefined, and if we are not
+// in the global scope, then we have an undefined variable error.
+
+ } else {
+ if (!option.undef) {
+ warn('used_before_a', token);
+ }
+ scope[name] = variable = {
+ string: name,
+ writeable: true,
+ function: funct
+ };
+ funct[name] = 'undef';
+ }
+
+ }
+ site = variable.function;
+
+// The name is in scope and defined in the current function.
+
+ if (funct === site) {
+
+// Change 'unused' to 'var', and reject labels.
+
+ switch (funct[name]) {
+ case 'becoming':
+ warn('unexpected_a', token);
+ funct[name] = 'var';
+ break;
+ case 'unused':
+ funct[name] = 'var';
+ break;
+ case 'unparam':
+ funct[name] = 'parameter';
+ break;
+ case 'unction':
+ funct[name] = 'function';
+ break;
+ case 'label':
+ warn('a_label', token, name);
+ break;
+ }
+ this.function = funct;
+
+// If the name is already defined in the current
+// function, but not as outer, then there is a scope error.
+
+ } else {
+ switch (funct[name]) {
+ case 'closure':
+ case 'function':
+ case 'var':
+ case 'unused':
+ warn('a_scope', token, name);
+ break;
+ case 'label':
+ warn('a_label', token, name);
+ break;
+ case 'outer':
+ case 'global':
+ break;
+ default:
+
+// If the name is defined in an outer function, make an outer entry, and if
+// it was unused, make it var.
+
+ switch (site[name]) {
+ case 'becoming':
+ case 'closure':
+ case 'function':
+ case 'parameter':
+ case 'unction':
+ case 'unused':
+ case 'var':
+ site[name] = 'closure';
+ funct[name] = site === global_funct
+ ? 'global'
+ : 'outer';
+ this.function = site;
+ break;
+ case 'unparam':
+ site[name] = 'parameter';
+ funct[name] = 'outer';
+ this.function = site;
+ break;
+ case 'undef':
+ funct[name] = 'undef';
+ break;
+ case 'label':
+ warn('a_label', token, name);
+ break;
+ }
+ }
+ }
+ return this;
+ },
+ led: function () {
+ stop('expected_operator_a');
+ }
+ };
+
+// Build the syntax table by declaring the syntactic elements.
+
+ type('(array)', 'array');
+ type('(color)', 'color');
+ type('(function)', 'function');
+ type('(number)', 'number', return_this);
+ type('(object)', 'object');
+ type('(string)', 'string', return_this);
+ type('(boolean)', 'boolean', return_this);
+ type('(range)', 'range');
+ type('(regexp)', 'regexp', return_this);
+
+ ultimate('(begin)');
+ ultimate('(end)');
+ ultimate('(error)');
+ postscript(symbol('');
+ postscript(symbol('}'));
+ symbol(')');
+ symbol(']');
+ postscript(symbol('"'));
+ postscript(symbol('\''));
+ symbol(';');
+ symbol(':');
+ symbol(',');
+ symbol('#');
+ symbol('@');
+ symbol('*/');
+ postscript(reserve('case'));
+ reserve('catch');
+ postscript(reserve('default'));
+ reserve('else');
+ reserve('finally');
+
+ reservevar('arguments', function (x) {
+ if (strict_mode && funct === global_funct) {
+ warn('strict', x);
+ } else if (option.safe) {
+ warn('adsafe_a', x);
+ }
+ funct['(arguments)'] = true;
+ });
+ reservevar('eval', function (x) {
+ if (option.safe) {
+ warn('adsafe_a', x);
+ }
+ });
+ constant('false', 'boolean');
+ constant('Infinity', 'number');
+ constant('NaN', 'number');
+ constant('null', '');
+ reservevar('this', function (x) {
+ if (option.safe) {
+ warn('adsafe_a', x);
+ } else if (strict_mode && funct['(token)'] &&
+ (funct['(token)'].arity === 'statement' &&
+ funct['(name)'].charAt(0) > 'Z')) {
+ warn('strict', x);
+ }
+ });
+ constant('true', 'boolean');
+ constant('undefined', '');
+
+ infix('?', 30, function (left, that) {
+ step_in('?');
+ that.first = expected_condition(expected_relation(left));
+ that.second = expression(0);
+ spaces();
+ step_out();
+ var colon = next_token;
+ advance(':');
+ step_in(':');
+ spaces();
+ that.third = expression(10);
+ that.arity = 'ternary';
+ if (are_similar(that.second, that.third)) {
+ warn('weird_ternary', colon);
+ } else if (are_similar(that.first, that.second)) {
+ warn('use_or', that);
+ }
+ step_out();
+ return that;
+ });
+
+ infix('||', 40, function (left, that) {
+ function paren_check(that) {
+ if (that.id === '&&' && !that.paren) {
+ warn('and', that);
+ }
+ return that;
+ }
+
+ that.first = paren_check(expected_condition(expected_relation(left)));
+ that.second = paren_check(expected_relation(expression(40)));
+ if (are_similar(that.first, that.second)) {
+ warn('weird_condition', that);
+ }
+ return that;
+ });
+
+ infix('&&', 50, function (left, that) {
+ that.first = expected_condition(expected_relation(left));
+ that.second = expected_relation(expression(50));
+ if (are_similar(that.first, that.second)) {
+ warn('weird_condition', that);
+ }
+ return that;
+ });
+
+ prefix('void', function (that) {
+ that.first = expression(0);
+ if (option.es5 || strict_mode) {
+ warn('expected_a_b', that, 'undefined', 'void');
+ } else if (that.first.number !== 0) {
+ warn('expected_a_b', that.first, '0', artifact(that.first));
+ }
+ return that;
+ });
+
+ bitwise('|', 70);
+ bitwise('^', 80);
+ bitwise('&', 90);
+
+ relation('==', '===');
+ relation('===');
+ relation('!=', '!==');
+ relation('!==');
+ relation('<');
+ relation('>');
+ relation('<=');
+ relation('>=');
+
+ bitwise('<<', 120);
+ bitwise('>>', 120);
+ bitwise('>>>', 120);
+
+ infix('in', 120, function (left, that) {
+ warn('infix_in', that);
+ that.left = left;
+ that.right = expression(130);
+ return that;
+ });
+ infix('instanceof', 120);
+ infix('+', 130, function (left, that) {
+ if (left.id === '(number)') {
+ if (left.number === 0) {
+ warn('unexpected_a', left, '0');
+ }
+ } else if (left.id === '(string)') {
+ if (left.string === '') {
+ warn('expected_a_b', left, 'String', '\'\'');
+ }
+ }
+ var right = expression(130);
+ if (right.id === '(number)') {
+ if (right.number === 0) {
+ warn('unexpected_a', right, '0');
+ }
+ } else if (right.id === '(string)') {
+ if (right.string === '') {
+ warn('expected_a_b', right, 'String', '\'\'');
+ }
+ }
+ if (left.id === right.id) {
+ if (left.id === '(string)' || left.id === '(number)') {
+ if (left.id === '(string)') {
+ left.string += right.string;
+ if (jx.test(left.string)) {
+ warn('url', left);
+ }
+ } else {
+ left.number += right.number;
+ }
+ left.thru = right.thru;
+ return left;
+ }
+ }
+ that.first = left;
+ that.second = right;
+ return that;
+ });
+ prefix('+');
+ prefix('+++', function () {
+ warn('confusing_a', token);
+ this.first = expression(150);
+ this.arity = 'prefix';
+ return this;
+ });
+ infix('+++', 130, function (left) {
+ warn('confusing_a', token);
+ this.first = left;
+ this.second = expression(130);
+ return this;
+ });
+ infix('-', 130, function (left, that) {
+ if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') {
+ warn('unexpected_a', left);
+ }
+ var right = expression(130);
+ if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') {
+ warn('unexpected_a', right);
+ }
+ if (left.id === right.id && left.id === '(number)') {
+ left.number -= right.number;
+ left.thru = right.thru;
+ return left;
+ }
+ that.first = left;
+ that.second = right;
+ return that;
+ });
+ prefix('-');
+ prefix('---', function () {
+ warn('confusing_a', token);
+ this.first = expression(150);
+ this.arity = 'prefix';
+ return this;
+ });
+ infix('---', 130, function (left) {
+ warn('confusing_a', token);
+ this.first = left;
+ this.second = expression(130);
+ return this;
+ });
+ infix('*', 140, function (left, that) {
+ if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') {
+ warn('unexpected_a', left);
+ }
+ var right = expression(140);
+ if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') {
+ warn('unexpected_a', right);
+ }
+ if (left.id === right.id && left.id === '(number)') {
+ left.number *= right.number;
+ left.thru = right.thru;
+ return left;
+ }
+ that.first = left;
+ that.second = right;
+ return that;
+ });
+ infix('/', 140, function (left, that) {
+ if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') {
+ warn('unexpected_a', left);
+ }
+ var right = expression(140);
+ if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') {
+ warn('unexpected_a', right);
+ }
+ if (left.id === right.id && left.id === '(number)') {
+ left.number /= right.number;
+ left.thru = right.thru;
+ return left;
+ }
+ that.first = left;
+ that.second = right;
+ return that;
+ });
+ infix('%', 140, function (left, that) {
+ if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') {
+ warn('unexpected_a', left);
+ }
+ var right = expression(140);
+ if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') {
+ warn('unexpected_a', right);
+ }
+ if (left.id === right.id && left.id === '(number)') {
+ left.number %= right.number;
+ left.thru = right.thru;
+ return left;
+ }
+ that.first = left;
+ that.second = right;
+ return that;
+ });
+
+ suffix('++');
+ prefix('++');
+
+ suffix('--');
+ prefix('--');
+ prefix('delete', function (that) {
+ one_space();
+ var p = expression(0);
+ if (!p || (p.id !== '.' && p.id !== '[')) {
+ warn('deleted');
+ }
+ that.first = p;
+ return that;
+ });
+
+
+ prefix('~', function (that) {
+ no_space_only();
+ if (!option.bitwise) {
+ warn('unexpected_a', that);
+ }
+ that.first = expression(150);
+ return that;
+ });
+ function banger(that) {
+ no_space_only();
+ that.first = expected_condition(expression(150));
+ if (bang[that.first.id] === that || that.first.assign) {
+ warn('confusing_a', that);
+ }
+ return that;
+ }
+ prefix('!', banger);
+ prefix('!!', banger);
+ prefix('typeof');
+ prefix('new', function (that) {
+ one_space();
+ var c = expression(160), n, p, v;
+ that.first = c;
+ if (c.id !== 'function') {
+ if (c.identifier) {
+ switch (c.string) {
+ case 'Object':
+ warn('use_object', token);
+ break;
+ case 'Array':
+ if (next_token.id === '(') {
+ p = next_token;
+ p.first = this;
+ advance('(');
+ if (next_token.id !== ')') {
+ n = expression(0);
+ p.second = [n];
+ if (n.id !== '(number)' || next_token.id === ',') {
+ warn('use_array', p);
+ }
+ while (next_token.id === ',') {
+ advance(',');
+ p.second.push(expression(0));
+ }
+ } else {
+ warn('use_array', token);
+ }
+ advance(')', p);
+ return p;
+ }
+ warn('use_array', token);
+ break;
+ case 'Number':
+ case 'String':
+ case 'Boolean':
+ case 'Math':
+ case 'JSON':
+ warn('not_a_constructor', c);
+ break;
+ case 'Function':
+ if (!option.evil) {
+ warn('function_eval');
+ }
+ break;
+ case 'Date':
+ case 'RegExp':
+ case 'this':
+ break;
+ default:
+ if (c.id !== 'function') {
+ v = c.string.charAt(0);
+ if (!option.newcap && (v < 'A' || v > 'Z')) {
+ warn('constructor_name_a', token);
+ }
+ }
+ }
+ } else {
+ if (c.id !== '.' && c.id !== '[' && c.id !== '(') {
+ warn('bad_constructor', token);
+ }
+ }
+ } else {
+ warn('weird_new', that);
+ }
+ if (next_token.id !== '(') {
+ warn('missing_a', next_token, '()');
+ }
+ return that;
+ });
+
+ infix('(', 160, function (left, that) {
+ var e, p;
+ if (indent && indent.mode === 'expression') {
+ no_space(prev_token, token);
+ } else {
+ no_space_only(prev_token, token);
+ }
+ if (!left.immed && left.id === 'function') {
+ warn('wrap_immediate');
+ }
+ p = [];
+ if (left.identifier) {
+ if (left.string.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
+ if (left.string !== 'Number' && left.string !== 'String' &&
+ left.string !== 'Boolean' && left.string !== 'Date') {
+ if (left.string === 'Math' || left.string === 'JSON') {
+ warn('not_a_function', left);
+ } else if (left.string === 'Object') {
+ warn('use_object', token);
+ } else if (left.string === 'Array' || !option.newcap) {
+ warn('missing_a', left, 'new');
+ }
+ }
+ }
+ } else if (left.id === '.') {
+ if (option.safe && left.first.string === 'Math' &&
+ left.second === 'random') {
+ warn('adsafe_a', left);
+ } else if (left.second.string === 'split' &&
+ left.first.id === '(string)') {
+ warn('use_array', left.second);
+ }
+ }
+ step_in();
+ if (next_token.id !== ')') {
+ no_space();
+ for (;;) {
+ edge();
+ e = expression(10);
+ if (left.string === 'Boolean' && (e.id === '!' || e.id === '~')) {
+ warn('weird_condition', e);
+ }
+ p.push(e);
+ if (next_token.id !== ',') {
+ break;
+ }
+ comma();
+ }
+ }
+ no_space();
+ step_out(')', that);
+ if (typeof left === 'object') {
+ if (left.string === 'parseInt' && p.length === 1) {
+ warn('radix', left);
+ } else if (left.string === 'String' && p.length >= 1 && p[0].id === '(string)') {
+ warn('unexpected_a', left);
+ }
+ if (!option.evil) {
+ if (left.string === 'eval' || left.string === 'Function' ||
+ left.string === 'execScript') {
+ warn('evil', left);
+ } else if (p[0] && p[0].id === '(string)' &&
+ (left.string === 'setTimeout' ||
+ left.string === 'setInterval')) {
+ warn('implied_evil', left);
+ }
+ }
+ if (!left.identifier && left.id !== '.' && left.id !== '[' &&
+ left.id !== '(' && left.id !== '&&' && left.id !== '||' &&
+ left.id !== '?') {
+ warn('bad_invocation', left);
+ }
+ if (left.id === '.') {
+ if (p.length > 0 &&
+ left.first && left.first.first &&
+ are_similar(p[0], left.first.first)) {
+ if (left.second.string === 'call' ||
+ (left.second.string === 'apply' && (p.length === 1 ||
+ (p[1].arity === 'prefix' && p[1].id === '[')))) {
+ warn('unexpected_a', left.second);
+ }
+ }
+ if (left.second.string === 'toString') {
+ if (left.first.id === '(string)' || left.first.id === '(number)') {
+ warn('unexpected_a', left.second);
+ }
+ }
+ }
+ }
+ that.first = left;
+ that.second = p;
+ return that;
+ }, true);
+
+ prefix('(', function (that) {
+ step_in('expression');
+ no_space();
+ edge();
+ if (next_token.id === 'function') {
+ next_token.immed = true;
+ }
+ var value = expression(0);
+ value.paren = true;
+ no_space();
+ step_out(')', that);
+ if (value.id === 'function') {
+ switch (next_token.id) {
+ case '(':
+ warn('move_invocation');
+ break;
+ case '.':
+ case '[':
+ warn('unexpected_a');
+ break;
+ default:
+ warn('bad_wrap', that);
+ }
+ } else if (!value.arity) {
+ warn('unexpected_a', that);
+ }
+ return value;
+ });
+
+ infix('.', 170, function (left, that) {
+ no_space(prev_token, token);
+ no_space();
+ var name = identifier();
+ if (typeof name === 'string') {
+ tally_property(name);
+ }
+ that.first = left;
+ that.second = token;
+ if (left && left.string === 'arguments' &&
+ (name === 'callee' || name === 'caller')) {
+ warn('avoid_a', left, 'arguments.' + name);
+ } else if (!option.evil && left && left.string === 'document' &&
+ (name === 'write' || name === 'writeln')) {
+ warn('write_is_wrong', left);
+ } else if (!option.stupid && syx.test(name)) {
+ warn('sync_a', token);
+ } else if (option.adsafe) {
+ if (!adsafe_top && left.string === 'ADSAFE') {
+ if (name === 'id' || name === 'lib') {
+ warn('adsafe_a', that);
+ } else if (name === 'go') {
+ if (xmode !== 'script') {
+ warn('adsafe_a', that);
+ } else if (adsafe_went || next_token.id !== '(' ||
+ peek(0).id !== '(string)' ||
+ peek(0).string !== adsafe_id ||
+ peek(1).id !== ',') {
+ stop('adsafe_a', that, 'go');
+ }
+ adsafe_went = true;
+ adsafe_may = false;
+ }
+ }
+ adsafe_top = false;
+ }
+ if (!option.evil && (name === 'eval' || name === 'execScript')) {
+ warn('evil');
+ } else if (option.safe) {
+ for (;;) {
+ if (banned[name] === true) {
+ warn('adsafe_a', token, name);
+ }
+ if (typeof predefined[left.string] !== 'boolean' || //// check for writeable
+ next_token.id === '(') {
+ break;
+ }
+ if (next_token.id !== '.') {
+ warn('adsafe_a', that);
+ break;
+ }
+ advance('.');
+ token.first = that;
+ token.second = name;
+ that = token;
+ name = identifier();
+ if (typeof name === 'string') {
+ tally_property(name);
+ }
+ }
+ }
+ return that;
+ }, true);
+
+ infix('[', 170, function (left, that) {
+ var e, s;
+ no_space_only(prev_token, token);
+ no_space();
+ step_in();
+ edge();
+ e = expression(0);
+ switch (e.id) {
+ case '(number)':
+ if (e.id === '(number)' && left.id === 'arguments') {
+ warn('use_param', left);
+ }
+ break;
+ case '(string)':
+ if (option.safe && (banned[e.string] ||
+ e.string.charAt(0) === '_' || e.string.slice(-1) === '_')) {
+ warn('adsafe_subscript_a', e);
+ } else if (!option.evil &&
+ (e.string === 'eval' || e.string === 'execScript')) {
+ warn('evil', e);
+ } else if (!option.sub && ix.test(e.string)) {
+ s = syntax[e.string];
+ if (!s || !s.reserved) {
+ warn('subscript', e);
+ }
+ }
+ tally_property(e.string);
+ break;
+ default:
+ if (option.safe) {
+ if ((e.id !== '+' || e.arity !== 'prefix') &&
+ e.id !== '-' && e.id !== '*') {
+ warn('adsafe_subscript_a', e);
+ }
+ }
+ }
+ step_out(']', that);
+ no_space(prev_token, token);
+ that.first = left;
+ that.second = e;
+ return that;
+ }, true);
+
+ prefix('[', function (that) {
+ that.first = [];
+ step_in('array');
+ while (next_token.id !== '(end)') {
+ while (next_token.id === ',') {
+ warn('unexpected_a', next_token);
+ advance(',');
+ }
+ if (next_token.id === ']') {
+ break;
+ }
+ indent.wrap = false;
+ edge();
+ that.first.push(expression(10));
+ if (next_token.id === ',') {
+ comma();
+ if (next_token.id === ']' && !option.es5) {
+ warn('unexpected_a', token);
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+ step_out(']', that);
+ return that;
+ }, 170);
+
+
+ function property_name() {
+ var id = optional_identifier();
+ if (!id) {
+ if (next_token.id === '(string)') {
+ id = next_token.string;
+ if (option.safe) {
+ if (banned[id]) {
+ warn('adsafe_a');
+ } else if (id.charAt(0) === '_' ||
+ id.charAt(id.length - 1) === '_') {
+ warn('dangling_a');
+ }
+ }
+ advance();
+ } else if (next_token.id === '(number)') {
+ id = next_token.number.toString();
+ advance();
+ }
+ }
+ return id;
+ }
+
+
+
+ assignop('=');
+ assignop('+=', '+');
+ assignop('-=', '-');
+ assignop('*=', '*');
+ assignop('/=', '/').nud = function () {
+ stop('slash_equal');
+ };
+ assignop('%=', '%');
+ assignop('&=', '&');
+ assignop('|=', '|');
+ assignop('^=', '^');
+ assignop('<<=', '<<');
+ assignop('>>=', '>>');
+ assignop('>>>=', '>>>');
+
+ function function_params() {
+ var id, paren = next_token, params = [];
+ advance('(');
+ token.function = funct;
+ step_in();
+ no_space();
+ if (next_token.id === ')') {
+ no_space();
+ step_out(')', paren);
+ return params;
+ }
+ for (;;) {
+ edge();
+ id = identifier();
+ params.push(token);
+ add_label(token, option.unparam ? 'parameter' : 'unparam');
+ if (next_token.id === ',') {
+ comma();
+ } else {
+ no_space();
+ step_out(')', paren);
+ return params;
+ }
+ }
+ }
+
+ function do_function(func, name) {
+ var old_funct = funct,
+ old_option = option,
+ old_scope = scope;
+ funct = {
+ '(name)' : name || '\'' + (anonname || '').replace(nx, sanitize) + '\'',
+ '(line)' : next_token.line,
+ '(context)' : old_funct,
+ '(breakage)' : 0,
+ '(loopage)' : 0,
+ '(scope)' : scope,
+ '(token)' : func,
+ '(level)' : old_funct['(level)'] + 1
+ };
+ func.function = funct;
+ option = Object.create(old_option);
+ scope = Object.create(old_scope);
+ functions.push(funct);
+ func.name = name;
+ func.function = funct;
+ if (name) {
+ add_label(func, 'function', name);
+ }
+ func.writeable = false;
+ func.first = funct['(params)'] = function_params();
+ one_space();
+ func.block = block(false);
+ if (funct['(arguments)']) {
+ func.first.forEach(function (value) {
+ if (value.assign) {
+ warn('parameter_arguments_a', value, value.string);
+ }
+ });
+ }
+ funct = old_funct;
+ option = old_option;
+ scope = old_scope;
+ }
+
+ prefix('{', function (that) {
+ var get, i, j, name, p, set, seen = {};
+ that.first = [];
+ step_in();
+ while (next_token.id !== '}') {
+ indent.wrap = false;
+
+// JSLint recognizes the ES5 extension for get/set in object literals,
+// but requires that they be used in pairs.
+
+ edge();
+ if (next_token.string === 'get' && peek().id !== ':') {
+ if (!option.es5) {
+ warn('es5');
+ }
+ get = next_token;
+ advance('get');
+ one_space_only();
+ name = next_token;
+ i = property_name();
+ if (!i) {
+ stop('missing_property');
+ }
+ get.string = '';
+ do_function(get);
+ if (funct['(loopage)']) {
+ warn('function_loop', get);
+ }
+ p = get.first;
+ if (p && p.length) {
+ warn('parameter_a_get_b', p[0], p[0].string, i);
+ }
+ comma();
+ set = next_token;
+ spaces();
+ edge();
+ advance('set');
+ set.string = '';
+ one_space_only();
+ j = property_name();
+ if (i !== j) {
+ stop('expected_a_b', token, i, j || next_token.string);
+ }
+ do_function(set);
+ if (set.block.length === 0) {
+ warn('missing_a', token, 'throw');
+ }
+ p = set.first;
+ if (!p || p.length !== 1) {
+ stop('parameter_set_a', set, 'value');
+ } else if (p[0].string !== 'value') {
+ stop('expected_a_b', p[0], 'value', p[0].string);
+ }
+ name.first = [get, set];
+ } else {
+ name = next_token;
+ i = property_name();
+ if (typeof i !== 'string') {
+ stop('missing_property');
+ }
+ advance(':');
+ spaces();
+ name.first = expression(10);
+ }
+ that.first.push(name);
+ if (seen[i] === true) {
+ warn('duplicate_a', next_token, i);
+ }
+ seen[i] = true;
+ tally_property(i);
+ if (next_token.id !== ',') {
+ break;
+ }
+ for (;;) {
+ comma();
+ if (next_token.id !== ',') {
+ break;
+ }
+ warn('unexpected_a', next_token);
+ }
+ if (next_token.id === '}' && !option.es5) {
+ warn('unexpected_a', token);
+ }
+ }
+ step_out('}', that);
+ return that;
+ });
+
+ stmt('{', function () {
+ warn('statement_block');
+ this.arity = 'statement';
+ this.block = statements();
+ this.disrupt = this.block.disrupt;
+ advance('}', this);
+ return this;
+ });
+
+ stmt('/*global', directive);
+ stmt('/*globals', directive);
+ stmt('/*jslint', directive);
+ stmt('/*member', directive);
+ stmt('/*members', directive);
+ stmt('/*property', directive);
+ stmt('/*properties', directive);
+
+ stmt('var', function () {
+
+// JavaScript does not have block scope. It only has function scope. So,
+// declaring a variable in a block can have unexpected consequences.
+
+// var.first will contain an array, the array containing name tokens
+// and assignment tokens.
+
+ var assign, id, name;
+
+ if (funct['(vars)'] && !option.vars) {
+ warn('combine_var');
+ } else if (funct !== global_funct) {
+ funct['(vars)'] = true;
+ }
+ this.arity = 'statement';
+ this.first = [];
+ step_in('var');
+ for (;;) {
+ name = next_token;
+ id = identifier(true);
+ add_label(name, 'becoming');
+
+ if (next_token.id === '=') {
+ assign = next_token;
+ assign.first = name;
+ spaces();
+ advance('=');
+ spaces();
+ if (next_token.id === 'undefined') {
+ warn('unnecessary_initialize', token, id);
+ }
+ if (peek(0).id === '=' && next_token.identifier) {
+ stop('var_a_not');
+ }
+ assign.second = expression(0);
+ assign.arity = 'infix';
+ this.first.push(assign);
+ } else {
+ this.first.push(name);
+ }
+ if (funct[id] === 'becoming') {
+ funct[id] = 'unused';
+ }
+ if (next_token.id !== ',') {
+ break;
+ }
+ comma();
+ indent.wrap = false;
+ if (var_mode && next_token.line === token.line &&
+ this.first.length === 1) {
+ var_mode = null;
+ indent.open = false;
+ indent.at -= option.indent;
+ }
+ spaces();
+ edge();
+ }
+ var_mode = null;
+ step_out();
+ return this;
+ });
+
+ stmt('function', function () {
+ one_space();
+ if (in_block) {
+ warn('function_block', token);
+ }
+ var name = next_token,
+ id = identifier(true);
+ add_label(name, 'unction');
+ no_space();
+ this.arity = 'statement';
+ do_function(this, id);
+ if (next_token.id === '(' && next_token.line === token.line) {
+ stop('function_statement');
+ }
+ return this;
+ });
+
+ prefix('function', function (that) {
+ if (!option.anon) {
+ one_space();
+ }
+ var id = optional_identifier(true);
+ if (id) {
+ no_space();
+ } else {
+ id = '';
+ }
+ do_function(that, id);
+ if (funct['(loopage)']) {
+ warn('function_loop');
+ }
+ switch (next_token.id) {
+ case ';':
+ case '(':
+ case ')':
+ case ',':
+ case ']':
+ case '}':
+ case ':':
+ break;
+ case '.':
+ if (peek().string !== 'bind' || peek(1).id !== '(') {
+ warn('unexpected_a');
+ }
+ break;
+ default:
+ stop('unexpected_a');
+ }
+ that.arity = 'function';
+ return that;
+ });
+
+ stmt('if', function () {
+ var paren = next_token;
+ one_space();
+ advance('(');
+ step_in('control');
+ no_space();
+ edge();
+ this.arity = 'statement';
+ this.first = expected_condition(expected_relation(expression(0)));
+ no_space();
+ step_out(')', paren);
+ one_space();
+ this.block = block(true);
+ if (next_token.id === 'else') {
+ one_space();
+ advance('else');
+ one_space();
+ this.else = next_token.id === 'if' || next_token.id === 'switch'
+ ? statement(true)
+ : block(true);
+ if (this.else.disrupt && this.block.disrupt) {
+ this.disrupt = true;
+ }
+ }
+ return this;
+ });
+
+ stmt('try', function () {
+
+// try.first The catch variable
+// try.second The catch clause
+// try.third The finally clause
+// try.block The try block
+
+ var exception_variable, old_scope, paren;
+ if (option.adsafe) {
+ warn('adsafe_a', this);
+ }
+ one_space();
+ this.arity = 'statement';
+ this.block = block(false);
+ if (next_token.id === 'catch') {
+ one_space();
+ advance('catch');
+ one_space();
+ paren = next_token;
+ advance('(');
+ step_in('control');
+ no_space();
+ edge();
+ old_scope = scope;
+ scope = Object.create(old_scope);
+ exception_variable = next_token.string;
+ this.first = exception_variable;
+ if (!next_token.identifier) {
+ warn('expected_identifier_a', next_token);
+ } else {
+ add_label(next_token, 'exception');
+ }
+ advance();
+ no_space();
+ step_out(')', paren);
+ one_space();
+ this.second = block(false);
+ scope = old_scope;
+ }
+ if (next_token.id === 'finally') {
+ one_space();
+ advance('finally');
+ one_space();
+ this.third = block(false);
+ } else if (!this.second) {
+ stop('expected_a_b', next_token, 'catch', artifact());
+ }
+ return this;
+ });
+
+ labeled_stmt('while', function () {
+ one_space();
+ var paren = next_token;
+ funct['(breakage)'] += 1;
+ funct['(loopage)'] += 1;
+ advance('(');
+ step_in('control');
+ no_space();
+ edge();
+ this.arity = 'statement';
+ this.first = expected_relation(expression(0));
+ if (this.first.id !== 'true') {
+ expected_condition(this.first, bundle.unexpected_a);
+ }
+ no_space();
+ step_out(')', paren);
+ one_space();
+ this.block = block(true);
+ if (this.block.disrupt) {
+ warn('strange_loop', prev_token);
+ }
+ funct['(breakage)'] -= 1;
+ funct['(loopage)'] -= 1;
+ return this;
+ });
+
+ reserve('with');
+
+ labeled_stmt('switch', function () {
+
+// switch.first the switch expression
+// switch.second the array of cases. A case is 'case' or 'default' token:
+// case.first the array of case expressions
+// case.second the array of statements
+// If all of the arrays of statements are disrupt, then the switch is disrupt.
+
+ var cases = [],
+ old_in_block = in_block,
+ particular,
+ that = token,
+ the_case = next_token,
+ unbroken = true;
+
+ function find_duplicate_case(value) {
+ if (are_similar(particular, value)) {
+ warn('duplicate_a', value);
+ }
+ }
+
+ funct['(breakage)'] += 1;
+ one_space();
+ advance('(');
+ no_space();
+ step_in();
+ this.arity = 'statement';
+ this.first = expected_condition(expected_relation(expression(0)));
+ no_space();
+ step_out(')', the_case);
+ one_space();
+ advance('{');
+ step_in();
+ in_block = true;
+ this.second = [];
+ if (that.from !== next_token.from && !option.white) {
+ warn('expected_a_at_b_c', next_token, next_token.string, that.from, next_token.from);
+ }
+ while (next_token.id === 'case') {
+ the_case = next_token;
+ cases.forEach(find_duplicate_case);
+ the_case.first = [];
+ the_case.arity = 'case';
+ spaces();
+ edge('case');
+ advance('case');
+ for (;;) {
+ one_space();
+ particular = expression(0);
+ cases.forEach(find_duplicate_case);
+ cases.push(particular);
+ the_case.first.push(particular);
+ if (particular.id === 'NaN') {
+ warn('unexpected_a', particular);
+ }
+ no_space_only();
+ advance(':');
+ if (next_token.id !== 'case') {
+ break;
+ }
+ spaces();
+ edge('case');
+ advance('case');
+ }
+ spaces();
+ the_case.second = statements();
+ if (the_case.second && the_case.second.length > 0) {
+ particular = the_case.second[the_case.second.length - 1];
+ if (particular.disrupt) {
+ if (particular.id === 'break') {
+ unbroken = false;
+ }
+ } else {
+ warn('missing_a_after_b', next_token, 'break', 'case');
+ }
+ } else {
+ warn('empty_case');
+ }
+ this.second.push(the_case);
+ }
+ if (this.second.length === 0) {
+ warn('missing_a', next_token, 'case');
+ }
+ if (next_token.id === 'default') {
+ spaces();
+ the_case = next_token;
+ the_case.arity = 'case';
+ edge('case');
+ advance('default');
+ no_space_only();
+ advance(':');
+ spaces();
+ the_case.second = statements();
+ if (the_case.second && the_case.second.length > 0) {
+ particular = the_case.second[the_case.second.length - 1];
+ if (unbroken && particular.disrupt && particular.id !== 'break') {
+ this.disrupt = true;
+ }
+ }
+ this.second.push(the_case);
+ }
+ funct['(breakage)'] -= 1;
+ spaces();
+ step_out('}', this);
+ in_block = old_in_block;
+ return this;
+ });
+
+ stmt('debugger', function () {
+ if (!option.debug) {
+ warn('unexpected_a', this);
+ }
+ this.arity = 'statement';
+ return this;
+ });
+
+ labeled_stmt('do', function () {
+ funct['(breakage)'] += 1;
+ funct['(loopage)'] += 1;
+ one_space();
+ this.arity = 'statement';
+ this.block = block(true);
+ if (this.block.disrupt) {
+ warn('strange_loop', prev_token);
+ }
+ one_space();
+ advance('while');
+ var paren = next_token;
+ one_space();
+ advance('(');
+ step_in();
+ no_space();
+ edge();
+ this.first = expected_condition(expected_relation(expression(0)), bundle.unexpected_a);
+ no_space();
+ step_out(')', paren);
+ funct['(breakage)'] -= 1;
+ funct['(loopage)'] -= 1;
+ return this;
+ });
+
+ labeled_stmt('for', function () {
+
+ var blok, filter, ok = false, paren = next_token, value;
+ this.arity = 'statement';
+ funct['(breakage)'] += 1;
+ funct['(loopage)'] += 1;
+ advance('(');
+ if (next_token.id === ';') {
+ no_space();
+ advance(';');
+ no_space();
+ advance(';');
+ no_space();
+ advance(')');
+ blok = block(true);
+ } else {
+ step_in('control');
+ spaces(this, paren);
+ no_space();
+ if (next_token.id === 'var') {
+ stop('move_var');
+ }
+ edge();
+ if (peek(0).id === 'in') {
+ this.forin = true;
+ value = next_token;
+ switch (funct[value.string]) {
+ case 'unused':
+ funct[value.string] = 'var';
+ break;
+ case 'closure':
+ case 'var':
+ break;
+ default:
+ warn('bad_in_a', value);
+ }
+ advance();
+ advance('in');
+ this.first = value;
+ this.second = expression(20);
+ step_out(')', paren);
+ blok = block(true);
+ if (!option.forin) {
+ if (blok.length === 1 && typeof blok[0] === 'object' &&
+ blok[0].string === 'if' && !blok[0].else) {
+ filter = blok[0].first;
+ while (filter.id === '&&') {
+ filter = filter.first;
+ }
+ switch (filter.id) {
+ case '===':
+ case '!==':
+ ok = filter.first.id === '['
+ ? filter.first.first.string === this.second.string &&
+ filter.first.second.string === this.first.string
+ : filter.first.id === 'typeof' &&
+ filter.first.first.id === '[' &&
+ filter.first.first.first.string === this.second.string &&
+ filter.first.first.second.string === this.first.string;
+ break;
+ case '(':
+ ok = filter.first.id === '.' && ((
+ filter.first.first.string === this.second.string &&
+ filter.first.second.string === 'hasOwnProperty' &&
+ filter.second[0].string === this.first.string
+ ) || (
+ filter.first.first.string === 'ADSAFE' &&
+ filter.first.second.string === 'has' &&
+ filter.second[0].string === this.second.string &&
+ filter.second[1].string === this.first.string
+ ) || (
+ filter.first.first.id === '.' &&
+ filter.first.first.first.id === '.' &&
+ filter.first.first.first.first.string === 'Object' &&
+ filter.first.first.first.second.string === 'prototype' &&
+ filter.first.first.second.string === 'hasOwnProperty' &&
+ filter.first.second.string === 'call' &&
+ filter.second[0].string === this.second.string &&
+ filter.second[1].string === this.first.string
+ ));
+ break;
+ }
+ }
+ if (!ok) {
+ warn('for_if', this);
+ }
+ }
+ } else {
+ edge();
+ this.first = [];
+ for (;;) {
+ this.first.push(expression(0, 'for'));
+ if (next_token.id !== ',') {
+ break;
+ }
+ comma();
+ }
+ semicolon();
+ edge();
+ this.second = expected_relation(expression(0));
+ if (this.second.id !== 'true') {
+ expected_condition(this.second, bundle.unexpected_a);
+ }
+ semicolon(token);
+ if (next_token.id === ';') {
+ stop('expected_a_b', next_token, ')', ';');
+ }
+ this.third = [];
+ edge();
+ for (;;) {
+ this.third.push(expression(0, 'for'));
+ if (next_token.id !== ',') {
+ break;
+ }
+ comma();
+ }
+ no_space();
+ step_out(')', paren);
+ one_space();
+ blok = block(true);
+ }
+ }
+ if (blok.disrupt) {
+ warn('strange_loop', prev_token);
+ }
+ this.block = blok;
+ funct['(breakage)'] -= 1;
+ funct['(loopage)'] -= 1;
+ return this;
+ });
+
+ disrupt_stmt('break', function () {
+ var label = next_token.string;
+ this.arity = 'statement';
+ if (funct['(breakage)'] === 0) {
+ warn('unexpected_a', this);
+ }
+ if (next_token.identifier && token.line === next_token.line) {
+ one_space_only();
+ if (funct[label] !== 'label') {
+ warn('not_a_label', next_token);
+ } else if (scope[label].function !== funct) {
+ warn('not_a_scope', next_token);
+ }
+ this.first = next_token;
+ advance();
+ }
+ return this;
+ });
+
+ disrupt_stmt('continue', function () {
+ if (!option.continue) {
+ warn('unexpected_a', this);
+ }
+ var label = next_token.string;
+ this.arity = 'statement';
+ if (funct['(breakage)'] === 0) {
+ warn('unexpected_a', this);
+ }
+ if (next_token.identifier && token.line === next_token.line) {
+ one_space_only();
+ if (funct[label] !== 'label') {
+ warn('not_a_label', next_token);
+ } else if (scope[label].function !== funct) {
+ warn('not_a_scope', next_token);
+ }
+ this.first = next_token;
+ advance();
+ }
+ return this;
+ });
+
+ disrupt_stmt('return', function () {
+ if (funct === global_funct && xmode !== 'scriptstring') {
+ warn('unexpected_a', this);
+ }
+ this.arity = 'statement';
+ if (next_token.id !== ';' && next_token.line === token.line) {
+ one_space_only();
+ if (next_token.id === '/' || next_token.id === '(regexp)') {
+ warn('wrap_regexp');
+ }
+ this.first = expression(0);
+ if (this.first.assign) {
+ warn('unexpected_a', this.first);
+ }
+ }
+ if (peek(0).id === '}' && peek(1).id === 'else') {
+ warn('unexpected_else', this);
+ }
+ return this;
+ });
+
+ disrupt_stmt('throw', function () {
+ this.arity = 'statement';
+ one_space_only();
+ this.first = expression(20);
+ return this;
+ });
+
+
+// Superfluous reserved words
+
+ reserve('class');
+ reserve('const');
+ reserve('enum');
+ reserve('export');
+ reserve('extends');
+ reserve('import');
+ reserve('super');
+
+// Harmony reserved words
+
+ reserve('implements');
+ reserve('interface');
+ reserve('let');
+ reserve('package');
+ reserve('private');
+ reserve('protected');
+ reserve('public');
+ reserve('static');
+ reserve('yield');
+
+
+// Parse JSON
+
+ function json_value() {
+
+ function json_object() {
+ var brace = next_token, object = {};
+ advance('{');
+ if (next_token.id !== '}') {
+ while (next_token.id !== '(end)') {
+ while (next_token.id === ',') {
+ warn('unexpected_a', next_token);
+ advance(',');
+ }
+ if (next_token.id !== '(string)') {
+ warn('expected_string_a');
+ }
+ if (object[next_token.string] === true) {
+ warn('duplicate_a');
+ } else if (next_token.string === '__proto__') {
+ warn('dangling_a');
+ } else {
+ object[next_token.string] = true;
+ }
+ advance();
+ advance(':');
+ json_value();
+ if (next_token.id !== ',') {
+ break;
+ }
+ advance(',');
+ if (next_token.id === '}') {
+ warn('unexpected_a', token);
+ break;
+ }
+ }
+ }
+ advance('}', brace);
+ }
+
+ function json_array() {
+ var bracket = next_token;
+ advance('[');
+ if (next_token.id !== ']') {
+ while (next_token.id !== '(end)') {
+ while (next_token.id === ',') {
+ warn('unexpected_a', next_token);
+ advance(',');
+ }
+ json_value();
+ if (next_token.id !== ',') {
+ break;
+ }
+ advance(',');
+ if (next_token.id === ']') {
+ warn('unexpected_a', token);
+ break;
+ }
+ }
+ }
+ advance(']', bracket);
+ }
+
+ switch (next_token.id) {
+ case '{':
+ json_object();
+ break;
+ case '[':
+ json_array();
+ break;
+ case 'true':
+ case 'false':
+ case 'null':
+ case '(number)':
+ case '(string)':
+ advance();
+ break;
+ case '-':
+ advance('-');
+ no_space_only();
+ advance('(number)');
+ break;
+ default:
+ stop('unexpected_a');
+ }
+ }
+
+
+// CSS parsing.
+
+ function css_name() {
+ if (next_token.identifier) {
+ advance();
+ return true;
+ }
+ }
+
+
+ function css_number() {
+ if (next_token.id === '-') {
+ advance('-');
+ no_space_only();
+ }
+ if (next_token.id === '(number)') {
+ advance('(number)');
+ return true;
+ }
+ }
+
+
+ function css_string() {
+ if (next_token.id === '(string)') {
+ advance();
+ return true;
+ }
+ }
+
+ function css_color() {
+ var i, number, paren, value;
+ if (next_token.identifier) {
+ value = next_token.string;
+ if (value === 'rgb' || value === 'rgba') {
+ advance();
+ paren = next_token;
+ advance('(');
+ for (i = 0; i < 3; i += 1) {
+ if (i) {
+ comma();
+ }
+ number = next_token.number;
+ if (next_token.id !== '(number)' || number < 0) {
+ warn('expected_positive_a', next_token);
+ advance();
+ } else {
+ advance();
+ if (next_token.id === '%') {
+ advance('%');
+ if (number > 100) {
+ warn('expected_percent_a', token, number);
+ }
+ } else {
+ if (number > 255) {
+ warn('expected_small_a', token, number);
+ }
+ }
+ }
+ }
+ if (value === 'rgba') {
+ comma();
+ number = next_token.number;
+ if (next_token.id !== '(number)' || number < 0 || number > 1) {
+ warn('expected_fraction_a', next_token);
+ }
+ advance();
+ if (next_token.id === '%') {
+ warn('unexpected_a');
+ advance('%');
+ }
+ }
+ advance(')', paren);
+ return true;
+ }
+ if (css_colorData[next_token.string] === true) {
+ advance();
+ return true;
+ }
+ } else if (next_token.id === '(color)') {
+ advance();
+ return true;
+ }
+ return false;
+ }
+
+
+ function css_length() {
+ if (next_token.id === '-') {
+ advance('-');
+ no_space_only();
+ }
+ if (next_token.id === '(number)') {
+ advance();
+ if (next_token.id !== '(string)' &&
+ css_lengthData[next_token.string] === true) {
+ no_space_only();
+ advance();
+ } else if (+token.number !== 0) {
+ warn('expected_linear_a');
+ }
+ return true;
+ }
+ return false;
+ }
+
+
+ function css_line_height() {
+ if (next_token.id === '-') {
+ advance('-');
+ no_space_only();
+ }
+ if (next_token.id === '(number)') {
+ advance();
+ if (next_token.id !== '(string)' &&
+ css_lengthData[next_token.string] === true) {
+ no_space_only();
+ advance();
+ }
+ return true;
+ }
+ return false;
+ }
+
+
+ function css_width() {
+ if (next_token.identifier) {
+ switch (next_token.string) {
+ case 'thin':
+ case 'medium':
+ case 'thick':
+ advance();
+ return true;
+ }
+ } else {
+ return css_length();
+ }
+ }
+
+
+ function css_margin() {
+ if (next_token.identifier) {
+ if (next_token.string === 'auto') {
+ advance();
+ return true;
+ }
+ } else {
+ return css_length();
+ }
+ }
+
+ function css_attr() {
+ if (next_token.identifier && next_token.string === 'attr') {
+ advance();
+ advance('(');
+ if (!next_token.identifier) {
+ warn('expected_name_a');
+ }
+ advance();
+ advance(')');
+ return true;
+ }
+ return false;
+ }
+
+
+ function css_comma_list() {
+ while (next_token.id !== ';') {
+ if (!css_name() && !css_string()) {
+ warn('expected_name_a');
+ }
+ if (next_token.id !== ',') {
+ return true;
+ }
+ comma();
+ }
+ }
+
+
+ function css_counter() {
+ if (next_token.identifier && next_token.string === 'counter') {
+ advance();
+ advance('(');
+ advance();
+ if (next_token.id === ',') {
+ comma();
+ if (next_token.id !== '(string)') {
+ warn('expected_string_a');
+ }
+ advance();
+ }
+ advance(')');
+ return true;
+ }
+ if (next_token.identifier && next_token.string === 'counters') {
+ advance();
+ advance('(');
+ if (!next_token.identifier) {
+ warn('expected_name_a');
+ }
+ advance();
+ if (next_token.id === ',') {
+ comma();
+ if (next_token.id !== '(string)') {
+ warn('expected_string_a');
+ }
+ advance();
+ }
+ if (next_token.id === ',') {
+ comma();
+ if (next_token.id !== '(string)') {
+ warn('expected_string_a');
+ }
+ advance();
+ }
+ advance(')');
+ return true;
+ }
+ return false;
+ }
+
+
+ function css_radius() {
+ return css_length() && (next_token.id !== '(number)' || css_length());
+ }
+
+
+ function css_shadow() {
+ for (;;) {
+ if (next_token.string === 'inset') {
+ advance();
+ }
+ for (;;) {
+ if (!css_length()) {
+ break;
+ }
+ }
+ css_color();
+ if (next_token.id !== ',') {
+ break;
+ }
+ advance(',');
+ }
+ return true;
+ }
+
+
+ function css_shape() {
+ var i;
+ if (next_token.identifier && next_token.string === 'rect') {
+ advance();
+ advance('(');
+ for (i = 0; i < 4; i += 1) {
+ if (!css_length()) {
+ warn('expected_number_a');
+ break;
+ }
+ }
+ advance(')');
+ return true;
+ }
+ return false;
+ }
+
+
+ function css_url() {
+ var c, url;
+ if (next_token.identifier && next_token.string === 'url') {
+ next_token = lex.range('(', ')');
+ url = next_token.string;
+ c = url.charAt(0);
+ if (c === '"' || c === '\'') {
+ if (url.slice(-1) !== c) {
+ warn('bad_url_a');
+ } else {
+ url = url.slice(1, -1);
+ if (url.indexOf(c) >= 0) {
+ warn('bad_url_a');
+ }
+ }
+ }
+ if (!url) {
+ warn('missing_url');
+ }
+ if (ux.test(url)) {
+ stop('bad_url_a');
+ }
+ urls.push(url);
+ advance();
+ return true;
+ }
+ return false;
+ }
+
+
+ css_any = [css_url, function () {
+ for (;;) {
+ if (next_token.identifier) {
+ switch (next_token.string.toLowerCase()) {
+ case 'url':
+ css_url();
+ break;
+ case 'expression':
+ warn('unexpected_a');
+ advance();
+ break;
+ default:
+ advance();
+ }
+ } else {
+ if (next_token.id === ';' || next_token.id === '!' ||
+ next_token.id === '(end)' || next_token.id === '}') {
+ return true;
+ }
+ advance();
+ }
+ }
+ }];
+
+
+ function font_face() {
+ advance_identifier('font-family');
+ advance(':');
+ if (!css_name() && !css_string()) {
+ stop('expected_name_a');
+ }
+ semicolon();
+ advance_identifier('src');
+ advance(':');
+ while (true) {
+ if (next_token.string === 'local') {
+ advance_identifier('local');
+ advance('(');
+ if (ux.test(next_token.string)) {
+ stop('bad_url_a');
+ }
+
+ if (!css_name() && !css_string()) {
+ stop('expected_name_a');
+ }
+ advance(')');
+ } else if (!css_url()) {
+ stop('expected_a_b', next_token, 'url', artifact());
+ }
+ if (next_token.id !== ',') {
+ break;
+ }
+ comma();
+ }
+ semicolon();
+ }
+
+
+ css_border_style = [
+ 'none', 'dashed', 'dotted', 'double', 'groove',
+ 'hidden', 'inset', 'outset', 'ridge', 'solid'
+ ];
+
+ css_break = [
+ 'auto', 'always', 'avoid', 'left', 'right'
+ ];
+
+ css_media = {
+ 'all': true,
+ 'braille': true,
+ 'embossed': true,
+ 'handheld': true,
+ 'print': true,
+ 'projection': true,
+ 'screen': true,
+ 'speech': true,
+ 'tty': true,
+ 'tv': true
+ };
+
+ css_overflow = [
+ 'auto', 'hidden', 'scroll', 'visible'
+ ];
+
+ css_attribute_data = {
+ background: [
+ true, 'background-attachment', 'background-color',
+ 'background-image', 'background-position', 'background-repeat'
+ ],
+ 'background-attachment': ['scroll', 'fixed'],
+ 'background-color': ['transparent', css_color],
+ 'background-image': ['none', css_url],
+ 'background-position': [
+ 2, [css_length, 'top', 'bottom', 'left', 'right', 'center']
+ ],
+ 'background-repeat': [
+ 'repeat', 'repeat-x', 'repeat-y', 'no-repeat'
+ ],
+ 'border': [true, 'border-color', 'border-style', 'border-width'],
+ 'border-bottom': [
+ true, 'border-bottom-color', 'border-bottom-style',
+ 'border-bottom-width'
+ ],
+ 'border-bottom-color': css_color,
+ 'border-bottom-left-radius': css_radius,
+ 'border-bottom-right-radius': css_radius,
+ 'border-bottom-style': css_border_style,
+ 'border-bottom-width': css_width,
+ 'border-collapse': ['collapse', 'separate'],
+ 'border-color': ['transparent', 4, css_color],
+ 'border-left': [
+ true, 'border-left-color', 'border-left-style', 'border-left-width'
+ ],
+ 'border-left-color': css_color,
+ 'border-left-style': css_border_style,
+ 'border-left-width': css_width,
+ 'border-radius': function () {
+ function count(separator) {
+ var n = 1;
+ if (separator) {
+ advance(separator);
+ }
+ if (!css_length()) {
+ return false;
+ }
+ while (next_token.id === '(number)') {
+ if (!css_length()) {
+ return false;
+ }
+ n += 1;
+ }
+ if (n > 4) {
+ warn('bad_style');
+ }
+ return true;
+ }
+
+ return count() && (next_token.id !== '/' || count('/'));
+ },
+ 'border-right': [
+ true, 'border-right-color', 'border-right-style',
+ 'border-right-width'
+ ],
+ 'border-right-color': css_color,
+ 'border-right-style': css_border_style,
+ 'border-right-width': css_width,
+ 'border-spacing': [2, css_length],
+ 'border-style': [4, css_border_style],
+ 'border-top': [
+ true, 'border-top-color', 'border-top-style', 'border-top-width'
+ ],
+ 'border-top-color': css_color,
+ 'border-top-left-radius': css_radius,
+ 'border-top-right-radius': css_radius,
+ 'border-top-style': css_border_style,
+ 'border-top-width': css_width,
+ 'border-width': [4, css_width],
+ bottom: [css_length, 'auto'],
+ 'box-shadow': ['none', css_shadow],
+ 'caption-side' : ['bottom', 'left', 'right', 'top'],
+ clear: ['both', 'left', 'none', 'right'],
+ clip: [css_shape, 'auto'],
+ color: css_color,
+ content: [
+ 'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote',
+ css_string, css_url, css_counter, css_attr
+ ],
+ 'counter-increment': [
+ css_name, 'none'
+ ],
+ 'counter-reset': [
+ css_name, 'none'
+ ],
+ cursor: [
+ css_url, 'auto', 'crosshair', 'default', 'e-resize', 'help', 'move',
+ 'n-resize', 'ne-resize', 'nw-resize', 'pointer', 's-resize',
+ 'se-resize', 'sw-resize', 'w-resize', 'text', 'wait'
+ ],
+ direction: ['ltr', 'rtl'],
+ display: [
+ 'block', 'compact', 'inline', 'inline-block', 'inline-table',
+ 'list-item', 'marker', 'none', 'run-in', 'table', 'table-caption',
+ 'table-cell', 'table-column', 'table-column-group',
+ 'table-footer-group', 'table-header-group', 'table-row',
+ 'table-row-group'
+ ],
+ 'empty-cells': ['show', 'hide'],
+ 'float': ['left', 'none', 'right'],
+ font: [
+ 'caption', 'icon', 'menu', 'message-box', 'small-caption',
+ 'status-bar', true, 'font-size', 'font-style', 'font-weight',
+ 'font-family'
+ ],
+ 'font-family': css_comma_list,
+ 'font-size': [
+ 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large',
+ 'xx-large', 'larger', 'smaller', css_length
+ ],
+ 'font-size-adjust': ['none', css_number],
+ 'font-stretch': [
+ 'normal', 'wider', 'narrower', 'ultra-condensed',
+ 'extra-condensed', 'condensed', 'semi-condensed',
+ 'semi-expanded', 'expanded', 'extra-expanded'
+ ],
+ 'font-style': [
+ 'normal', 'italic', 'oblique'
+ ],
+ 'font-variant': [
+ 'normal', 'small-caps'
+ ],
+ 'font-weight': [
+ 'normal', 'bold', 'bolder', 'lighter', css_number
+ ],
+ height: [css_length, 'auto'],
+ left: [css_length, 'auto'],
+ 'letter-spacing': ['normal', css_length],
+ 'line-height': ['normal', css_line_height],
+ 'list-style': [
+ true, 'list-style-image', 'list-style-position', 'list-style-type'
+ ],
+ 'list-style-image': ['none', css_url],
+ 'list-style-position': ['inside', 'outside'],
+ 'list-style-type': [
+ 'circle', 'disc', 'square', 'decimal', 'decimal-leading-zero',
+ 'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha',
+ 'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'katakana',
+ 'hiragana-iroha', 'katakana-oroha', 'none'
+ ],
+ margin: [4, css_margin],
+ 'margin-bottom': css_margin,
+ 'margin-left': css_margin,
+ 'margin-right': css_margin,
+ 'margin-top': css_margin,
+ 'marker-offset': [css_length, 'auto'],
+ 'max-height': [css_length, 'none'],
+ 'max-width': [css_length, 'none'],
+ 'min-height': css_length,
+ 'min-width': css_length,
+ opacity: css_number,
+ outline: [true, 'outline-color', 'outline-style', 'outline-width'],
+ 'outline-color': ['invert', css_color],
+ 'outline-style': [
+ 'dashed', 'dotted', 'double', 'groove', 'inset', 'none',
+ 'outset', 'ridge', 'solid'
+ ],
+ 'outline-width': css_width,
+ overflow: css_overflow,
+ 'overflow-x': css_overflow,
+ 'overflow-y': css_overflow,
+ padding: [4, css_length],
+ 'padding-bottom': css_length,
+ 'padding-left': css_length,
+ 'padding-right': css_length,
+ 'padding-top': css_length,
+ 'page-break-after': css_break,
+ 'page-break-before': css_break,
+ position: ['absolute', 'fixed', 'relative', 'static'],
+ quotes: [8, css_string],
+ right: [css_length, 'auto'],
+ 'table-layout': ['auto', 'fixed'],
+ 'text-align': ['center', 'justify', 'left', 'right'],
+ 'text-decoration': [
+ 'none', 'underline', 'overline', 'line-through', 'blink'
+ ],
+ 'text-indent': css_length,
+ 'text-shadow': ['none', 4, [css_color, css_length]],
+ 'text-transform': ['capitalize', 'uppercase', 'lowercase', 'none'],
+ top: [css_length, 'auto'],
+ 'unicode-bidi': ['normal', 'embed', 'bidi-override'],
+ 'vertical-align': [
+ 'baseline', 'bottom', 'sub', 'super', 'top', 'text-top', 'middle',
+ 'text-bottom', css_length
+ ],
+ visibility: ['visible', 'hidden', 'collapse'],
+ 'white-space': [
+ 'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'inherit'
+ ],
+ width: [css_length, 'auto'],
+ 'word-spacing': ['normal', css_length],
+ 'word-wrap': ['break-word', 'normal'],
+ 'z-index': ['auto', css_number]
+ };
+
+ function style_attribute() {
+ var v;
+ while (next_token.id === '*' || next_token.id === '#' ||
+ next_token.string === '_') {
+ if (!option.css) {
+ warn('unexpected_a');
+ }
+ advance();
+ }
+ if (next_token.id === '-') {
+ if (!option.css) {
+ warn('unexpected_a');
+ }
+ advance('-');
+ if (!next_token.identifier) {
+ warn('expected_nonstandard_style_attribute');
+ }
+ advance();
+ return css_any;
+ }
+ if (!next_token.identifier) {
+ warn('expected_style_attribute');
+ } else {
+ if (Object.prototype.hasOwnProperty.call(css_attribute_data,
+ next_token.string)) {
+ v = css_attribute_data[next_token.string];
+ } else {
+ v = css_any;
+ if (!option.css) {
+ warn('unrecognized_style_attribute_a');
+ }
+ }
+ }
+ advance();
+ return v;
+ }
+
+
+ function style_value(v) {
+ var i = 0,
+ n,
+ once,
+ match,
+ round,
+ start = 0,
+ vi;
+ switch (typeof v) {
+ case 'function':
+ return v();
+ case 'string':
+ if (next_token.identifier && next_token.string === v) {
+ advance();
+ return true;
+ }
+ return false;
+ }
+ for (;;) {
+ if (i >= v.length) {
+ return false;
+ }
+ vi = v[i];
+ i += 1;
+ if (typeof vi === 'boolean') {
+ break;
+ } else if (typeof vi === 'number') {
+ n = vi;
+ vi = v[i];
+ i += 1;
+ } else {
+ n = 1;
+ }
+ match = false;
+ while (n > 0) {
+ if (style_value(vi)) {
+ match = true;
+ n -= 1;
+ } else {
+ break;
+ }
+ }
+ if (match) {
+ return true;
+ }
+ }
+ start = i;
+ once = [];
+ for (;;) {
+ round = false;
+ for (i = start; i < v.length; i += 1) {
+ if (!once[i]) {
+ if (style_value(css_attribute_data[v[i]])) {
+ match = true;
+ round = true;
+ once[i] = true;
+ break;
+ }
+ }
+ }
+ if (!round) {
+ return match;
+ }
+ }
+ }
+
+ function style_child() {
+ if (next_token.id === '(number)') {
+ advance();
+ if (next_token.string === 'n' && next_token.identifier) {
+ no_space_only();
+ advance();
+ if (next_token.id === '+') {
+ no_space_only();
+ advance('+');
+ no_space_only();
+ advance('(number)');
+ }
+ }
+ return;
+ }
+ if (next_token.identifier &&
+ (next_token.string === 'odd' || next_token.string === 'even')) {
+ advance();
+ return;
+ }
+ warn('unexpected_a');
+ }
+
+ function substyle() {
+ var v;
+ for (;;) {
+ if (next_token.id === '}' || next_token.id === '(end)' ||
+ (xquote && next_token.id === xquote)) {
+ return;
+ }
+ v = style_attribute();
+ advance(':');
+ if (next_token.identifier && next_token.string === 'inherit') {
+ advance();
+ } else {
+ if (!style_value(v)) {
+ warn('unexpected_a');
+ advance();
+ }
+ }
+ if (next_token.id === '!') {
+ advance('!');
+ no_space_only();
+ if (next_token.identifier && next_token.string === 'important') {
+ advance();
+ } else {
+ warn('expected_a_b',
+ next_token, 'important', artifact());
+ }
+ }
+ if (next_token.id === '}' || next_token.id === xquote) {
+ warn('expected_a_b', next_token, ';', artifact());
+ } else {
+ semicolon();
+ }
+ }
+ }
+
+ function style_selector() {
+ if (next_token.identifier) {
+ if (!Object.prototype.hasOwnProperty.call(html_tag,
+ next_token.string)) {
+ warn('expected_tagname_a');
+ }
+ advance();
+ } else {
+ switch (next_token.id) {
+ case '>':
+ case '+':
+ advance();
+ style_selector();
+ break;
+ case ':':
+ advance(':');
+ switch (next_token.string) {
+ case 'active':
+ case 'after':
+ case 'before':
+ case 'checked':
+ case 'disabled':
+ case 'empty':
+ case 'enabled':
+ case 'first-child':
+ case 'first-letter':
+ case 'first-line':
+ case 'first-of-type':
+ case 'focus':
+ case 'hover':
+ case 'last-child':
+ case 'last-of-type':
+ case 'link':
+ case 'only-of-type':
+ case 'root':
+ case 'target':
+ case 'visited':
+ advance_identifier(next_token.string);
+ break;
+ case 'lang':
+ advance_identifier('lang');
+ advance('(');
+ if (!next_token.identifier) {
+ warn('expected_lang_a');
+ }
+ advance(')');
+ break;
+ case 'nth-child':
+ case 'nth-last-child':
+ case 'nth-last-of-type':
+ case 'nth-of-type':
+ advance_identifier(next_token.string);
+ advance('(');
+ style_child();
+ advance(')');
+ break;
+ case 'not':
+ advance_identifier('not');
+ advance('(');
+ if (next_token.id === ':' && peek(0).string === 'not') {
+ warn('not');
+ }
+ style_selector();
+ advance(')');
+ break;
+ default:
+ warn('expected_pseudo_a');
+ }
+ break;
+ case '#':
+ advance('#');
+ if (!next_token.identifier) {
+ warn('expected_id_a');
+ }
+ advance();
+ break;
+ case '*':
+ advance('*');
+ break;
+ case '.':
+ advance('.');
+ if (!next_token.identifier) {
+ warn('expected_class_a');
+ }
+ advance();
+ break;
+ case '[':
+ advance('[');
+ if (!next_token.identifier) {
+ warn('expected_attribute_a');
+ }
+ advance();
+ if (next_token.id === '=' || next_token.string === '~=' ||
+ next_token.string === '$=' ||
+ next_token.string === '|=' ||
+ next_token.id === '*=' ||
+ next_token.id === '^=') {
+ advance();
+ if (next_token.id !== '(string)') {
+ warn('expected_string_a');
+ }
+ advance();
+ }
+ advance(']');
+ break;
+ default:
+ stop('expected_selector_a');
+ }
+ }
+ }
+
+ function style_pattern() {
+ if (next_token.id === '{') {
+ warn('expected_style_pattern');
+ }
+ for (;;) {
+ style_selector();
+ if (next_token.id === '= 0) {
+ warn('unexpected_char_a_b', token, v.charAt(x), a);
+ }
+ ids[u] = true;
+ } else if (a === 'class' || a === 'type' || a === 'name') {
+ x = v.search(qx);
+ if (x >= 0) {
+ warn('unexpected_char_a_b', token, v.charAt(x), a);
+ }
+ ids[u] = true;
+ } else if (a === 'href' || a === 'background' ||
+ a === 'content' || a === 'data' ||
+ a.indexOf('src') >= 0 || a.indexOf('url') >= 0) {
+ if (option.safe && ux.test(v)) {
+ stop('bad_url_a', next_token, v);
+ }
+ urls.push(v);
+ } else if (a === 'for') {
+ if (option.adsafe) {
+ if (adsafe_id) {
+ if (v.slice(0, adsafe_id.length) !== adsafe_id) {
+ warn('adsafe_prefix_a', next_token, adsafe_id);
+ } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
+ warn('adsafe_bad_id');
+ }
+ } else {
+ warn('adsafe_bad_id');
+ }
+ }
+ } else if (a === 'name') {
+ if (option.adsafe && v.indexOf('_') >= 0) {
+ warn('adsafe_name_a', next_token, v);
+ }
+ }
+ }
+
+ function do_tag(tag, name, attribute) {
+ var i, script, x;
+ src = false;
+ if (stack.length > 0) {
+ if (name === 'html') {
+ stop('unexpected_a', token, name);
+ }
+ x = tag.parent;
+ if (x) {
+ if (x.indexOf(' ' + stack[stack.length - 1].name + ' ') < 0) {
+ stop('tag_a_in_b', token, name, x);
+ }
+ } else if (x !== false && !option.adsafe && !option.fragment) {
+ i = stack.length;
+ do {
+ if (i <= 0) {
+ stop('tag_a_in_b', token, name, 'body');
+ }
+ i -= 1;
+ } while (stack[i].name !== 'body');
+ }
+ }
+ switch (name) {
+ case 'div':
+ if (option.adsafe && stack.length === 1 && !adsafe_id) {
+ warn('adsafe_missing_id');
+ }
+ break;
+ case 'script':
+ xmode = 'script';
+ advance('>');
+ if (attribute.lang) {
+ warn('lang', token);
+ }
+ if (option.adsafe && stack.length !== 1) {
+ warn('adsafe_placement', token);
+ }
+ if (attribute.src) {
+ if (option.adsafe && (!adsafe_may || !approved[attribute.src])) {
+ warn('adsafe_source', token);
+ }
+ } else {
+ step_in(next_token.from);
+ edge();
+ use_strict();
+ adsafe_top = true;
+ script = statements();
+
+// JSLint is also the static analyzer for ADsafe. See www.ADsafe.org.
+
+ if (option.adsafe) {
+ if (adsafe_went) {
+ stop('adsafe_script', token);
+ }
+ if (script.length !== 1 ||
+ aint(script[0], 'id', '(') ||
+ aint(script[0].first, 'id', '.') ||
+ aint(script[0].first.first, 'string', 'ADSAFE') ||
+ aint(script[0].second[0], 'string', adsafe_id)) {
+ stop('adsafe_id_go');
+ }
+ switch (script[0].first.second.string) {
+ case 'id':
+ if (adsafe_may || adsafe_went ||
+ script[0].second.length !== 1) {
+ stop('adsafe_id', next_token);
+ }
+ adsafe_may = true;
+ break;
+ case 'go':
+ if (adsafe_went) {
+ stop('adsafe_go');
+ }
+ if (script[0].second.length !== 2 ||
+ aint(script[0].second[1], 'id', 'function') ||
+ !script[0].second[1].first ||
+ aint(script[0].second[1].first[0], 'string', 'dom') ||
+ script[0].second[1].first.length > 2 ||
+ (script[0].second[1].first.length === 2 &&
+ aint(script[0].second[1].first[1], 'string', 'lib'))) {
+ stop('adsafe_go', next_token);
+ }
+ adsafe_went = true;
+ break;
+ default:
+ stop('adsafe_id_go');
+ }
+ }
+ indent = null;
+ }
+ xmode = 'html';
+ advance('');
+ styles();
+ xmode = 'html';
+ advance('';
+ }
+
+ function html() {
+ var attribute, attributes, is_empty, name, old_white = option.white,
+ quote, tag_name, tag, value, wmode;
+ xmode = 'html';
+ xquote = '';
+ stack = null;
+ for (;;) {
+ switch (next_token.string) {
+ case '<':
+ xmode = 'html';
+ advance('<');
+ attributes = {};
+ tag_name = next_token;
+ name = tag_name.string;
+ advance_identifier(name);
+ tag_name.name = name;
+ if (!stack) {
+ stack = [];
+ do_begin(name);
+ }
+ tag = html_tag[name];
+ if (typeof tag !== 'object') {
+ tag = {parent: false};
+ warn('unrecognized_tag_a', tag_name, name === name.toLowerCase()
+ ? name
+ : name + ' (capitalization error)');
+ } else {
+ is_empty = tag.empty;
+ }
+ tag_name.type = name;
+ for (;;) {
+ if (next_token.id === '/') {
+ advance('/');
+ if (next_token.id !== '>') {
+ warn('expected_a_b', next_token, '>', artifact());
+ }
+ break;
+ }
+ if (next_token.id && next_token.id.charAt(0) === '>') {
+ break;
+ }
+ if (!next_token.identifier) {
+ if (next_token.id === '(end)' || next_token.id === '(error)') {
+ warn('expected_a_b', next_token, '>', artifact());
+ }
+ warn('bad_name_a');
+ }
+ option.white = false;
+ spaces();
+ attribute = next_token.string;
+ option.white = old_white;
+ advance();
+ if (attribute !== attribute.toLowerCase()) {
+ warn('attribute_case_a', token);
+ }
+ attribute = attribute.toLowerCase();
+ xquote = '';
+ if (Object.prototype.hasOwnProperty.call(attributes, attribute)) {
+ warn('duplicate_a', token, attribute);
+ }
+ if (attribute.slice(0, 2) === 'on') {
+ if (!option.on) {
+ warn('html_handlers');
+ }
+ xmode = 'scriptstring';
+ advance('=');
+ quote = next_token.id;
+ if (quote !== '"' && quote !== '\'') {
+ stop('expected_a_b', next_token, '"', artifact());
+ }
+ xquote = quote;
+ wmode = option.white;
+ option.white = true;
+ advance(quote);
+ use_strict();
+ statements();
+ option.white = wmode;
+ if (next_token.id !== quote) {
+ stop('expected_a_b', next_token, quote, artifact());
+ }
+ xmode = 'html';
+ xquote = '';
+ advance(quote);
+ value = false;
+ } else if (attribute === 'style') {
+ xmode = 'scriptstring';
+ advance('=');
+ quote = next_token.id;
+ if (quote !== '"' && quote !== '\'') {
+ stop('expected_a_b', next_token, '"', artifact());
+ }
+ xmode = 'styleproperty';
+ xquote = quote;
+ advance(quote);
+ substyle();
+ xmode = 'html';
+ xquote = '';
+ advance(quote);
+ value = false;
+ } else {
+ if (next_token.id === '=') {
+ advance('=');
+ value = next_token.string;
+ if (!next_token.identifier &&
+ next_token.id !== '"' &&
+ next_token.id !== '\'' &&
+ next_token.id !== '(string)' &&
+ next_token.id !== '(number)' &&
+ next_token.id !== '(color)') {
+ warn('expected_attribute_value_a', token, attribute);
+ }
+ advance();
+ } else {
+ value = true;
+ }
+ }
+ attributes[attribute] = value;
+ do_attribute(attribute, value);
+ }
+ do_tag(tag, name, attributes);
+ if (!is_empty) {
+ stack.push(tag_name);
+ }
+ xmode = 'outer';
+ advance('>');
+ break;
+ case '') {
+ stop('expected_a_b', next_token, '>', artifact());
+ }
+ xmode = 'outer';
+ advance('>');
+ break;
+ case '' || next_token.id === '(end)') {
+ break;
+ }
+ if (next_token.string.indexOf('--') >= 0) {
+ stop('unexpected_a', next_token, '--');
+ }
+ if (next_token.string.indexOf('<') >= 0) {
+ stop('unexpected_a', next_token, '<');
+ }
+ if (next_token.string.indexOf('>') >= 0) {
+ stop('unexpected_a', next_token, '>');
+ }
+ }
+ xmode = 'outer';
+ advance('>');
+ break;
+ case '(end)':
+ if (stack.length !== 0) {
+ warn('missing_a', next_token, '');
+ }
+ return;
+ default:
+ if (next_token.id === '(end)') {
+ stop('missing_a', next_token,
+ '');
+ } else {
+ advance();
+ }
+ }
+ if (stack && stack.length === 0 && (option.adsafe ||
+ !option.fragment || next_token.id === '(end)')) {
+ break;
+ }
+ }
+ if (next_token.id !== '(end)') {
+ stop('unexpected_a');
+ }
+ }
+
+
+// The actual JSLINT function itself.
+
+ itself = function JSLint(the_source, the_option) {
+
+ var i, predef, tree;
+ JSLINT.errors = [];
+ JSLINT.tree = '';
+ JSLINT.properties = '';
+ begin = prev_token = token = next_token =
+ Object.create(syntax['(begin)']);
+ tokens = [];
+ predefined = {};
+ add_to_predefined(standard);
+ property = {};
+ if (the_option) {
+ option = Object.create(the_option);
+ predef = option.predef;
+ if (predef) {
+ if (Array.isArray(predef)) {
+ for (i = 0; i < predef.length; i += 1) {
+ predefined[predef[i]] = true;
+ }
+ } else if (typeof predef === 'object') {
+ add_to_predefined(predef);
+ }
+ }
+ do_safe();
+ } else {
+ option = {};
+ }
+ option.indent = +option.indent || 4;
+ option.maxerr = +option.maxerr || 50;
+ adsafe_id = '';
+ adsafe_may = adsafe_top = adsafe_went = false;
+ approved = {};
+ if (option.approved) {
+ for (i = 0; i < option.approved.length; i += 1) {
+ approved[option.approved[i]] = option.approved[i];
+ }
+ } else {
+ approved.test = 'test';
+ }
+ tab = '';
+ for (i = 0; i < option.indent; i += 1) {
+ tab += ' ';
+ }
+ global_scope = scope = {};
+ global_funct = funct = {
+ '(scope)': scope,
+ '(breakage)': 0,
+ '(loopage)': 0,
+ '(level)': 0
+ };
+ functions = [funct];
+
+ comments_off = false;
+ ids = {};
+ in_block = false;
+ indent = null;
+ json_mode = false;
+ lookahead = [];
+ node_js = false;
+ prereg = true;
+ src = false;
+ stack = null;
+ strict_mode = false;
+ urls = [];
+ var_mode = null;
+ warnings = 0;
+ xmode = '';
+ lex.init(the_source);
+
+ assume();
+
+ try {
+ advance();
+ if (next_token.id === '(number)') {
+ stop('unexpected_a');
+ } else if (next_token.string.charAt(0) === '<') {
+ html();
+ if (option.adsafe && !adsafe_went) {
+ warn('adsafe_go', this);
+ }
+ } else {
+ switch (next_token.id) {
+ case '{':
+ case '[':
+ json_mode = true;
+ json_value();
+ break;
+ case '@':
+ case '*':
+ case '#':
+ case '.':
+ case ':':
+ xmode = 'style';
+ advance();
+ if (token.id !== '@' || !next_token.identifier ||
+ next_token.string !== 'charset' || token.line !== 1 ||
+ token.from !== 1) {
+ stop('css');
+ }
+ advance();
+ if (next_token.id !== '(string)' &&
+ next_token.string !== 'UTF-8') {
+ stop('css');
+ }
+ advance();
+ semicolon();
+ styles();
+ break;
+
+ default:
+ if (option.adsafe && option.fragment) {
+ stop('expected_a_b',
+ next_token, '
', artifact());
+ }
+
+// If the first token is a semicolon, ignore it. This is sometimes used when
+// files are intended to be appended to files that may be sloppy. A sloppy
+// file may be depending on semicolon insertion on its last line.
+
+ step_in(1);
+ if (next_token.id === ';' && !node_js) {
+ semicolon();
+ }
+ adsafe_top = true;
+ tree = statements();
+ begin.first = tree;
+ itself.tree = begin;
+ if (option.adsafe && (tree.length !== 1 ||
+ aint(tree[0], 'id', '(') ||
+ aint(tree[0].first, 'id', '.') ||
+ aint(tree[0].first.first, 'string', 'ADSAFE') ||
+ aint(tree[0].first.second, 'string', 'lib') ||
+ tree[0].second.length !== 2 ||
+ tree[0].second[0].id !== '(string)' ||
+ aint(tree[0].second[1], 'id', 'function'))) {
+ stop('adsafe_lib');
+ }
+ if (tree.disrupt) {
+ warn('weird_program', prev_token);
+ }
+ }
+ }
+ indent = null;
+ advance('(end)');
+ itself.property = property;
+ } catch (e) {
+ if (e) { // ~~
+ JSLINT.errors.push({
+ reason : e.message,
+ line : e.line || next_token.line,
+ character : e.character || next_token.from
+ }, null);
+ }
+ }
+ return JSLINT.errors.length === 0;
+ };
+
+
+// Data summary.
+
+ itself.data = function () {
+ var data = {functions: []},
+ function_data,
+ globals,
+ i,
+ j,
+ kind,
+ name,
+ the_function,
+ undef = [],
+ unused = [];
+ if (itself.errors.length) {
+ data.errors = itself.errors;
+ }
+
+ if (json_mode) {
+ data.json = true;
+ }
+
+ if (urls.length > 0) {
+ data.urls = urls;
+ }
+
+ globals = Object.keys(global_scope).filter(function (value) {
+ return value.charAt(0) !== '(' && typeof standard[value] !== 'boolean';
+ });
+ if (globals.length > 0) {
+ data.globals = globals;
+ }
+
+ for (i = 1; i < functions.length; i += 1) {
+ the_function = functions[i];
+ function_data = {};
+ for (j = 0; j < functionicity.length; j += 1) {
+ function_data[functionicity[j]] = [];
+ }
+ for (name in the_function) {
+ if (Object.prototype.hasOwnProperty.call(the_function, name)) {
+ if (name.charAt(0) !== '(') {
+ kind = the_function[name];
+ if (kind === 'unction' || kind === 'unparam') {
+ kind = 'unused';
+ }
+ if (Array.isArray(function_data[kind])) {
+ function_data[kind].push(name);
+ if (kind === 'unused') {
+ unused.push({
+ name: name,
+ line: the_function['(line)'],
+ 'function': the_function['(name)']
+ });
+ } else if (kind === 'undef') {
+ undef.push({
+ name: name,
+ line: the_function['(line)'],
+ 'function': the_function['(name)']
+ });
+ }
+ }
+ }
+ }
+ }
+ for (j = 0; j < functionicity.length; j += 1) {
+ if (function_data[functionicity[j]].length === 0) {
+ delete function_data[functionicity[j]];
+ }
+ }
+ function_data.name = the_function['(name)'];
+ function_data.params = the_function['(params)'];
+ function_data.line = the_function['(line)'];
+ function_data.level = the_function['(level)'];
+ data.functions.push(function_data);
+ }
+
+ if (unused.length > 0) {
+ data.unused = unused;
+ }
+ if (undef.length > 0) {
+ data.undefined = undef;
+ }
+ data.tokens = tokens;
+ return data;
+ };
+
+ itself.error_report = function (data) {
+ var evidence, i, output = [], snippets, warning;
+ if (data.errors) {
+ if (data.json) {
+ output.push('
JSON: bad.');
+ }
+ for (i = 0; i < data.errors.length; i += 1) {
+ warning = data.errors[i];
+ if (warning) {
+ evidence = warning.evidence || '';
+ output.push('
');
+ if (isFinite(warning.line)) {
+ output.push('line ' +
+ String(warning.line) +
+ ' character ' + String(warning.character) +
+ '');
+ }
+ output.push(warning.reason.entityify() + '');
+ if (evidence) {
+ output.push('
' + evidence.entityify() + '
');
+ }
+ }
+ }
+ }
+ if (data.unused || data.undefined) {
+ output.push('
');
+ if (data.undefined) {
+ output.push('- undefined
- ');
+ snippets = [];
+ for (i = 0; i < data.undefined.length; i += 1) {
+ snippets[i] = '
' + data.undefined[i].name +
+ ' ' +
+ data.undefined[i]['function'] + ' ' +
+ String(data.undefined[i].line) + '';
+ }
+ output.push(snippets.join(', '));
+ output.push(' ');
+ }
+ if (data.unused) {
+ output.push('- unused
- ');
+ snippets = [];
+ for (i = 0; i < data.unused.length; i += 1) {
+ snippets[i] = '
' + data.unused[i].name + ' ' +
+ data.unused[i].function + ' ' +
+ String(data.unused[i].line) + '';
+ }
+ output.push(snippets.join(', '));
+ output.push(' ');
+ }
+ output.push('
');
+ }
+ return output.join('');
+ };
+
+
+ itself.report = function (data) {
+ var dl, i, j, names, output = [], the_function;
+
+ function detail(h, value) {
+ var comma_needed, singularity;
+ if (Array.isArray(value)) {
+ output.push("
" + h + "");
+ value.sort().forEach(function (item) {
+ if (item !== singularity) {
+ singularity = item;
+ output.push((comma_needed ? ', ' : '') + singularity);
+ comma_needed = true;
+ }
+ });
+ output.push("");
+ } else if (value) {
+ output.push("
" + h + "", value, "");
+ }
+ }
+
+ output.push('
');
+ if (data.urls) {
+ detail('url', data.urls);
+ dl = true;
+ }
+ if (data.globals) {
+ detail('global', data.globals);
+ dl = true;
+ } else if (xmode === 'style') {
+ output.push("- CSS.
");
+ } else if (data.json) {
+ if (!data.errors) {
+ output.push("- JSON: good.
");
+ }
+ } else {
+ output.push("- No new global variables introduced.
");
+ }
+ if (dl) {
+ output.push("
");
+ } else {
+ output[0] = '';
+ }
+
+ if (data.functions) {
+ for (i = 0; i < data.functions.length; i += 1) {
+ the_function = data.functions[i];
+ names = [];
+ if (the_function.params) {
+ for (j = 0; j < the_function.params.length; j += 1) {
+ names[j] = the_function.params[j].string;
+ }
+ }
+ output.push('
line ' + String(the_function.line) +
+ '' + the_function.name.entityify() + '(' +
+ names.join(', ') + ')');
+ detail('undefined', the_function.undefined);
+ detail('unused', the_function.unused);
+ detail('closure', the_function.closure);
+ detail('variable', the_function.var);
+ detail('exception', the_function.exception);
+ detail('outer', the_function.outer);
+ detail('global', the_function.global);
+ detail('label', the_function.label);
+ output.push('
');
+ }
+ }
+ return output.join('');
+ };
+
+ itself.properties_report = function (property) {
+ if (!property) {
+ return '';
+ }
+ var i,
+ key,
+ keys = Object.keys(property).sort(),
+ length,
+ mem = ' ',
+ name,
+ not_first = false,
+ output = ['/*properties'];
+ for (i = 0; i < keys.length; i += 1) {
+ key = keys[i];
+ if (property[key] > 0) {
+ if (not_first) {
+ mem += ', ';
+ }
+ name = ix.test(key)
+ ? key
+ : '\'' + key.replace(nx, sanitize) + '\'';
+ length += name.length + 2;
+ if (mem.length + name.length >= 80) {
+ output.push(mem);
+ mem = ' ';
+ }
+ mem += name;
+ not_first = true;
+ }
+ }
+ output.push(mem, '*/\n');
+ return output.join('\n');
+ };
+
+ itself.color = function (data) {
+ var from,
+ i = 1,
+ level,
+ line,
+ result = [],
+ thru,
+ token = data.tokens[0];
+ while (token && token.id !== '(end)') {
+ from = token.from;
+ line = token.line;
+ thru = token.thru;
+ level = token.function['(level)'];
+ do {
+ thru = token.thru;
+ token = data.tokens[i];
+ i += 1;
+ } while (token && token.line === line && token.from - thru < 5 &&
+ level === token.function['(level)']);
+ result.push({
+ line: line,
+ level: level,
+ from: from,
+ thru: thru
+ });
+ }
+ return result;
+ };
+
+ itself.jslint = itself;
+
+ itself.edition = '2013-02-18';
+
+ return itself;
+}());
\ No newline at end of file
diff --git a/html/admin/test/lib/underscore.js b/html/admin/test/lib/underscore.js
new file mode 100644
index 0000000000..4d83099fd9
--- /dev/null
+++ b/html/admin/test/lib/underscore.js
@@ -0,0 +1,1221 @@
+// Underscore.js 1.4.3
+// http://underscorejs.org
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+ // Baseline setup
+ // --------------
+
+ // Establish the root object, `window` in the browser, or `global` on the server.
+ var root = this;
+
+ // Save the previous value of the `_` variable.
+ var previousUnderscore = root._;
+
+ // Establish the object that gets returned to break out of a loop iteration.
+ var breaker = {};
+
+ // Save bytes in the minified (but not gzipped) version:
+ var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+ // Create quick reference variables for speed access to core prototypes.
+ var push = ArrayProto.push,
+ slice = ArrayProto.slice,
+ concat = ArrayProto.concat,
+ toString = ObjProto.toString,
+ hasOwnProperty = ObjProto.hasOwnProperty;
+
+ // All **ECMAScript 5** native function implementations that we hope to use
+ // are declared here.
+ var
+ nativeForEach = ArrayProto.forEach,
+ nativeMap = ArrayProto.map,
+ nativeReduce = ArrayProto.reduce,
+ nativeReduceRight = ArrayProto.reduceRight,
+ nativeFilter = ArrayProto.filter,
+ nativeEvery = ArrayProto.every,
+ nativeSome = ArrayProto.some,
+ nativeIndexOf = ArrayProto.indexOf,
+ nativeLastIndexOf = ArrayProto.lastIndexOf,
+ nativeIsArray = Array.isArray,
+ nativeKeys = Object.keys,
+ nativeBind = FuncProto.bind;
+
+ // Create a safe reference to the Underscore object for use below.
+ var _ = function(obj) {
+ if (obj instanceof _) return obj;
+ if (!(this instanceof _)) return new _(obj);
+ this._wrapped = obj;
+ };
+
+ // Export the Underscore object for **Node.js**, with
+ // backwards-compatibility for the old `require()` API. If we're in
+ // the browser, add `_` as a global object via a string identifier,
+ // for Closure Compiler "advanced" mode.
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ exports = module.exports = _;
+ }
+ exports._ = _;
+ } else {
+ root._ = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.4.3';
+
+ // Collection Functions
+ // --------------------
+
+ // The cornerstone, an `each` implementation, aka `forEach`.
+ // Handles objects with the built-in `forEach`, arrays, and raw objects.
+ // Delegates to **ECMAScript 5**'s native `forEach` if available.
+ var each = _.each = _.forEach = function(obj, iterator, context) {
+ if (obj == null) return;
+ if (nativeForEach && obj.forEach === nativeForEach) {
+ obj.forEach(iterator, context);
+ } else if (obj.length === +obj.length) {
+ for (var i = 0, l = obj.length; i < l; i++) {
+ if (iterator.call(context, obj[i], i, obj) === breaker) return;
+ }
+ } else {
+ for (var key in obj) {
+ if (_.has(obj, key)) {
+ if (iterator.call(context, obj[key], key, obj) === breaker) return;
+ }
+ }
+ }
+ };
+
+ // Return the results of applying the iterator to each element.
+ // Delegates to **ECMAScript 5**'s native `map` if available.
+ _.map = _.collect = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+ each(obj, function(value, index, list) {
+ results[results.length] = iterator.call(context, value, index, list);
+ });
+ return results;
+ };
+
+ var reduceError = 'Reduce of empty array with no initial value';
+
+ // **Reduce** builds up a single result from a list of values, aka `inject`,
+ // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+ _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduce && obj.reduce === nativeReduce) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+ }
+ each(obj, function(value, index, list) {
+ if (!initial) {
+ memo = value;
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, value, index, list);
+ }
+ });
+ if (!initial) throw new TypeError(reduceError);
+ return memo;
+ };
+
+ // The right-associative version of reduce, also known as `foldr`.
+ // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+ _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+ }
+ var length = obj.length;
+ if (length !== +length) {
+ var keys = _.keys(obj);
+ length = keys.length;
+ }
+ each(obj, function(value, index, list) {
+ index = keys ? keys[--length] : --length;
+ if (!initial) {
+ memo = obj[index];
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, obj[index], index, list);
+ }
+ });
+ if (!initial) throw new TypeError(reduceError);
+ return memo;
+ };
+
+ // Return the first value which passes a truth test. Aliased as `detect`.
+ _.find = _.detect = function(obj, iterator, context) {
+ var result;
+ any(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) {
+ result = value;
+ return true;
+ }
+ });
+ return result;
+ };
+
+ // Return all the elements that pass a truth test.
+ // Delegates to **ECMAScript 5**'s native `filter` if available.
+ // Aliased as `select`.
+ _.filter = _.select = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+ each(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Return all the elements for which a truth test fails.
+ _.reject = function(obj, iterator, context) {
+ return _.filter(obj, function(value, index, list) {
+ return !iterator.call(context, value, index, list);
+ }, context);
+ };
+
+ // Determine whether all of the elements match a truth test.
+ // Delegates to **ECMAScript 5**'s native `every` if available.
+ // Aliased as `all`.
+ _.every = _.all = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = true;
+ if (obj == null) return result;
+ if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+ each(obj, function(value, index, list) {
+ if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if at least one element in the object matches a truth test.
+ // Delegates to **ECMAScript 5**'s native `some` if available.
+ // Aliased as `any`.
+ var any = _.some = _.any = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = false;
+ if (obj == null) return result;
+ if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+ each(obj, function(value, index, list) {
+ if (result || (result = iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if the array or object contains a given value (using `===`).
+ // Aliased as `include`.
+ _.contains = _.include = function(obj, target) {
+ if (obj == null) return false;
+ if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+ return any(obj, function(value) {
+ return value === target;
+ });
+ };
+
+ // Invoke a method (with arguments) on every item in a collection.
+ _.invoke = function(obj, method) {
+ var args = slice.call(arguments, 2);
+ return _.map(obj, function(value) {
+ return (_.isFunction(method) ? method : value[method]).apply(value, args);
+ });
+ };
+
+ // Convenience version of a common use case of `map`: fetching a property.
+ _.pluck = function(obj, key) {
+ return _.map(obj, function(value){ return value[key]; });
+ };
+
+ // Convenience version of a common use case of `filter`: selecting only objects
+ // with specific `key:value` pairs.
+ _.where = function(obj, attrs) {
+ if (_.isEmpty(attrs)) return [];
+ return _.filter(obj, function(value) {
+ for (var key in attrs) {
+ if (attrs[key] !== value[key]) return false;
+ }
+ return true;
+ });
+ };
+
+ // Return the maximum element or (element-based computation).
+ // Can't optimize arrays of integers longer than 65,535 elements.
+ // See: https://bugs.webkit.org/show_bug.cgi?id=80797
+ _.max = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+ return Math.max.apply(Math, obj);
+ }
+ if (!iterator && _.isEmpty(obj)) return -Infinity;
+ var result = {computed : -Infinity, value: -Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed >= result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Return the minimum element (or element-based computation).
+ _.min = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+ return Math.min.apply(Math, obj);
+ }
+ if (!iterator && _.isEmpty(obj)) return Infinity;
+ var result = {computed : Infinity, value: Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed < result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Shuffle an array.
+ _.shuffle = function(obj) {
+ var rand;
+ var index = 0;
+ var shuffled = [];
+ each(obj, function(value) {
+ rand = _.random(index++);
+ shuffled[index - 1] = shuffled[rand];
+ shuffled[rand] = value;
+ });
+ return shuffled;
+ };
+
+ // An internal function to generate lookup iterators.
+ var lookupIterator = function(value) {
+ return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+ };
+
+ // Sort the object's values by a criterion produced by an iterator.
+ _.sortBy = function(obj, value, context) {
+ var iterator = lookupIterator(value);
+ return _.pluck(_.map(obj, function(value, index, list) {
+ return {
+ value : value,
+ index : index,
+ criteria : iterator.call(context, value, index, list)
+ };
+ }).sort(function(left, right) {
+ var a = left.criteria;
+ var b = right.criteria;
+ if (a !== b) {
+ if (a > b || a === void 0) return 1;
+ if (a < b || b === void 0) return -1;
+ }
+ return left.index < right.index ? -1 : 1;
+ }), 'value');
+ };
+
+ // An internal function used for aggregate "group by" operations.
+ var group = function(obj, value, context, behavior) {
+ var result = {};
+ var iterator = lookupIterator(value || _.identity);
+ each(obj, function(value, index) {
+ var key = iterator.call(context, value, index, obj);
+ behavior(result, key, value);
+ });
+ return result;
+ };
+
+ // Groups the object's values by a criterion. Pass either a string attribute
+ // to group by, or a function that returns the criterion.
+ _.groupBy = function(obj, value, context) {
+ return group(obj, value, context, function(result, key, value) {
+ (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+ });
+ };
+
+ // Counts instances of an object that group by a certain criterion. Pass
+ // either a string attribute to count by, or a function that returns the
+ // criterion.
+ _.countBy = function(obj, value, context) {
+ return group(obj, value, context, function(result, key) {
+ if (!_.has(result, key)) result[key] = 0;
+ result[key]++;
+ });
+ };
+
+ // Use a comparator function to figure out the smallest index at which
+ // an object should be inserted so as to maintain order. Uses binary search.
+ _.sortedIndex = function(array, obj, iterator, context) {
+ iterator = iterator == null ? _.identity : lookupIterator(iterator);
+ var value = iterator.call(context, obj);
+ var low = 0, high = array.length;
+ while (low < high) {
+ var mid = (low + high) >>> 1;
+ iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+ }
+ return low;
+ };
+
+ // Safely convert anything iterable into a real, live array.
+ _.toArray = function(obj) {
+ if (!obj) return [];
+ if (_.isArray(obj)) return slice.call(obj);
+ if (obj.length === +obj.length) return _.map(obj, _.identity);
+ return _.values(obj);
+ };
+
+ // Return the number of elements in an object.
+ _.size = function(obj) {
+ if (obj == null) return 0;
+ return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+ };
+
+ // Array Functions
+ // ---------------
+
+ // Get the first element of an array. Passing **n** will return the first N
+ // values in the array. Aliased as `head` and `take`. The **guard** check
+ // allows it to work with `_.map`.
+ _.first = _.head = _.take = function(array, n, guard) {
+ if (array == null) return void 0;
+ return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+ };
+
+ // Returns everything but the last entry of the array. Especially useful on
+ // the arguments object. Passing **n** will return all the values in
+ // the array, excluding the last N. The **guard** check allows it to work with
+ // `_.map`.
+ _.initial = function(array, n, guard) {
+ return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+ };
+
+ // Get the last element of an array. Passing **n** will return the last N
+ // values in the array. The **guard** check allows it to work with `_.map`.
+ _.last = function(array, n, guard) {
+ if (array == null) return void 0;
+ if ((n != null) && !guard) {
+ return slice.call(array, Math.max(array.length - n, 0));
+ } else {
+ return array[array.length - 1];
+ }
+ };
+
+ // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+ // Especially useful on the arguments object. Passing an **n** will return
+ // the rest N values in the array. The **guard**
+ // check allows it to work with `_.map`.
+ _.rest = _.tail = _.drop = function(array, n, guard) {
+ return slice.call(array, (n == null) || guard ? 1 : n);
+ };
+
+ // Trim out all falsy values from an array.
+ _.compact = function(array) {
+ return _.filter(array, _.identity);
+ };
+
+ // Internal implementation of a recursive `flatten` function.
+ var flatten = function(input, shallow, output) {
+ each(input, function(value) {
+ if (_.isArray(value)) {
+ shallow ? push.apply(output, value) : flatten(value, shallow, output);
+ } else {
+ output.push(value);
+ }
+ });
+ return output;
+ };
+
+ // Return a completely flattened version of an array.
+ _.flatten = function(array, shallow) {
+ return flatten(array, shallow, []);
+ };
+
+ // Return a version of the array that does not contain the specified value(s).
+ _.without = function(array) {
+ return _.difference(array, slice.call(arguments, 1));
+ };
+
+ // Produce a duplicate-free version of the array. If the array has already
+ // been sorted, you have the option of using a faster algorithm.
+ // Aliased as `unique`.
+ _.uniq = _.unique = function(array, isSorted, iterator, context) {
+ if (_.isFunction(isSorted)) {
+ context = iterator;
+ iterator = isSorted;
+ isSorted = false;
+ }
+ var initial = iterator ? _.map(array, iterator, context) : array;
+ var results = [];
+ var seen = [];
+ each(initial, function(value, index) {
+ if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+ seen.push(value);
+ results.push(array[index]);
+ }
+ });
+ return results;
+ };
+
+ // Produce an array that contains the union: each distinct element from all of
+ // the passed-in arrays.
+ _.union = function() {
+ return _.uniq(concat.apply(ArrayProto, arguments));
+ };
+
+ // Produce an array that contains every item shared between all the
+ // passed-in arrays.
+ _.intersection = function(array) {
+ var rest = slice.call(arguments, 1);
+ return _.filter(_.uniq(array), function(item) {
+ return _.every(rest, function(other) {
+ return _.indexOf(other, item) >= 0;
+ });
+ });
+ };
+
+ // Take the difference between one array and a number of other arrays.
+ // Only the elements present in just the first array will remain.
+ _.difference = function(array) {
+ var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+ return _.filter(array, function(value){ return !_.contains(rest, value); });
+ };
+
+ // Zip together multiple lists into a single array -- elements that share
+ // an index go together.
+ _.zip = function() {
+ var args = slice.call(arguments);
+ var length = _.max(_.pluck(args, 'length'));
+ var results = new Array(length);
+ for (var i = 0; i < length; i++) {
+ results[i] = _.pluck(args, "" + i);
+ }
+ return results;
+ };
+
+ // Converts lists into objects. Pass either a single array of `[key, value]`
+ // pairs, or two parallel arrays of the same length -- one of keys, and one of
+ // the corresponding values.
+ _.object = function(list, values) {
+ if (list == null) return {};
+ var result = {};
+ for (var i = 0, l = list.length; i < l; i++) {
+ if (values) {
+ result[list[i]] = values[i];
+ } else {
+ result[list[i][0]] = list[i][1];
+ }
+ }
+ return result;
+ };
+
+ // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+ // we need this function. Return the position of the first occurrence of an
+ // item in an array, or -1 if the item is not included in the array.
+ // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+ // If the array is large and already in sort order, pass `true`
+ // for **isSorted** to use binary search.
+ _.indexOf = function(array, item, isSorted) {
+ if (array == null) return -1;
+ var i = 0, l = array.length;
+ if (isSorted) {
+ if (typeof isSorted == 'number') {
+ i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+ } else {
+ i = _.sortedIndex(array, item);
+ return array[i] === item ? i : -1;
+ }
+ }
+ if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+ for (; i < l; i++) if (array[i] === item) return i;
+ return -1;
+ };
+
+ // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+ _.lastIndexOf = function(array, item, from) {
+ if (array == null) return -1;
+ var hasIndex = from != null;
+ if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+ return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+ }
+ var i = (hasIndex ? from : array.length);
+ while (i--) if (array[i] === item) return i;
+ return -1;
+ };
+
+ // Generate an integer Array containing an arithmetic progression. A port of
+ // the native Python `range()` function. See
+ // [the Python documentation](http://docs.python.org/library/functions.html#range).
+ _.range = function(start, stop, step) {
+ if (arguments.length <= 1) {
+ stop = start || 0;
+ start = 0;
+ }
+ step = arguments[2] || 1;
+
+ var len = Math.max(Math.ceil((stop - start) / step), 0);
+ var idx = 0;
+ var range = new Array(len);
+
+ while(idx < len) {
+ range[idx++] = start;
+ start += step;
+ }
+
+ return range;
+ };
+
+ // Function (ahem) Functions
+ // ------------------
+
+ // Reusable constructor function for prototype setting.
+ var ctor = function(){};
+
+ // Create a function bound to a given object (assigning `this`, and arguments,
+ // optionally). Binding with arguments is also known as `curry`.
+ // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
+ // We check for `func.bind` first, to fail fast when `func` is undefined.
+ _.bind = function(func, context) {
+ var args, bound;
+ if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+ if (!_.isFunction(func)) throw new TypeError;
+ args = slice.call(arguments, 2);
+ return bound = function() {
+ if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+ ctor.prototype = func.prototype;
+ var self = new ctor;
+ ctor.prototype = null;
+ var result = func.apply(self, args.concat(slice.call(arguments)));
+ if (Object(result) === result) return result;
+ return self;
+ };
+ };
+
+ // Bind all of an object's methods to that object. Useful for ensuring that
+ // all callbacks defined on an object belong to it.
+ _.bindAll = function(obj) {
+ var funcs = slice.call(arguments, 1);
+ if (funcs.length == 0) funcs = _.functions(obj);
+ each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+ return obj;
+ };
+
+ // Memoize an expensive function by storing its results.
+ _.memoize = function(func, hasher) {
+ var memo = {};
+ hasher || (hasher = _.identity);
+ return function() {
+ var key = hasher.apply(this, arguments);
+ return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+ };
+ };
+
+ // Delays a function for the given number of milliseconds, and then calls
+ // it with the arguments supplied.
+ _.delay = function(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function(){ return func.apply(null, args); }, wait);
+ };
+
+ // Defers a function, scheduling it to run after the current call stack has
+ // cleared.
+ _.defer = function(func) {
+ return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+ };
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time.
+ _.throttle = function(func, wait) {
+ var context, args, timeout, result;
+ var previous = 0;
+ var later = function() {
+ previous = new Date;
+ timeout = null;
+ result = func.apply(context, args);
+ };
+ return function() {
+ var now = new Date;
+ var remaining = wait - (now - previous);
+ context = this;
+ args = arguments;
+ if (remaining <= 0) {
+ clearTimeout(timeout);
+ timeout = null;
+ previous = now;
+ result = func.apply(context, args);
+ } else if (!timeout) {
+ timeout = setTimeout(later, remaining);
+ }
+ return result;
+ };
+ };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // N milliseconds. If `immediate` is passed, trigger the function on the
+ // leading edge, instead of the trailing.
+ _.debounce = function(func, wait, immediate) {
+ var timeout, result;
+ return function() {
+ var context = this, args = arguments;
+ var later = function() {
+ timeout = null;
+ if (!immediate) result = func.apply(context, args);
+ };
+ var callNow = immediate && !timeout;
+ clearTimeout(timeout);
+ timeout = setTimeout(later, wait);
+ if (callNow) result = func.apply(context, args);
+ return result;
+ };
+ };
+
+ // Returns a function that will be executed at most one time, no matter how
+ // often you call it. Useful for lazy initialization.
+ _.once = function(func) {
+ var ran = false, memo;
+ return function() {
+ if (ran) return memo;
+ ran = true;
+ memo = func.apply(this, arguments);
+ func = null;
+ return memo;
+ };
+ };
+
+ // Returns the first function passed as an argument to the second,
+ // allowing you to adjust arguments, run code before and after, and
+ // conditionally execute the original function.
+ _.wrap = function(func, wrapper) {
+ return function() {
+ var args = [func];
+ push.apply(args, arguments);
+ return wrapper.apply(this, args);
+ };
+ };
+
+ // Returns a function that is the composition of a list of functions, each
+ // consuming the return value of the function that follows.
+ _.compose = function() {
+ var funcs = arguments;
+ return function() {
+ var args = arguments;
+ for (var i = funcs.length - 1; i >= 0; i--) {
+ args = [funcs[i].apply(this, args)];
+ }
+ return args[0];
+ };
+ };
+
+ // Returns a function that will only be executed after being called N times.
+ _.after = function(times, func) {
+ if (times <= 0) return func();
+ return function() {
+ if (--times < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ };
+
+ // Object Functions
+ // ----------------
+
+ // Retrieve the names of an object's properties.
+ // Delegates to **ECMAScript 5**'s native `Object.keys`
+ _.keys = nativeKeys || function(obj) {
+ if (obj !== Object(obj)) throw new TypeError('Invalid object');
+ var keys = [];
+ for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+ return keys;
+ };
+
+ // Retrieve the values of an object's properties.
+ _.values = function(obj) {
+ var values = [];
+ for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+ return values;
+ };
+
+ // Convert an object into a list of `[key, value]` pairs.
+ _.pairs = function(obj) {
+ var pairs = [];
+ for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+ return pairs;
+ };
+
+ // Invert the keys and values of an object. The values must be serializable.
+ _.invert = function(obj) {
+ var result = {};
+ for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+ return result;
+ };
+
+ // Return a sorted list of the function names available on the object.
+ // Aliased as `methods`
+ _.functions = _.methods = function(obj) {
+ var names = [];
+ for (var key in obj) {
+ if (_.isFunction(obj[key])) names.push(key);
+ }
+ return names.sort();
+ };
+
+ // Extend a given object with all the properties in passed-in object(s).
+ _.extend = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ if (source) {
+ for (var prop in source) {
+ obj[prop] = source[prop];
+ }
+ }
+ });
+ return obj;
+ };
+
+ // Return a copy of the object only containing the whitelisted properties.
+ _.pick = function(obj) {
+ var copy = {};
+ var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+ each(keys, function(key) {
+ if (key in obj) copy[key] = obj[key];
+ });
+ return copy;
+ };
+
+ // Return a copy of the object without the blacklisted properties.
+ _.omit = function(obj) {
+ var copy = {};
+ var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+ for (var key in obj) {
+ if (!_.contains(keys, key)) copy[key] = obj[key];
+ }
+ return copy;
+ };
+
+ // Fill in a given object with default properties.
+ _.defaults = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ if (source) {
+ for (var prop in source) {
+ if (obj[prop] == null) obj[prop] = source[prop];
+ }
+ }
+ });
+ return obj;
+ };
+
+ // Create a (shallow-cloned) duplicate of an object.
+ _.clone = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+ };
+
+ // Invokes interceptor with the obj, and then returns obj.
+ // The primary purpose of this method is to "tap into" a method chain, in
+ // order to perform operations on intermediate results within the chain.
+ _.tap = function(obj, interceptor) {
+ interceptor(obj);
+ return obj;
+ };
+
+ // Internal recursive comparison function for `isEqual`.
+ var eq = function(a, b, aStack, bStack) {
+ // Identical objects are equal. `0 === -0`, but they aren't identical.
+ // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
+ if (a === b) return a !== 0 || 1 / a == 1 / b;
+ // A strict comparison is necessary because `null == undefined`.
+ if (a == null || b == null) return a === b;
+ // Unwrap any wrapped objects.
+ if (a instanceof _) a = a._wrapped;
+ if (b instanceof _) b = b._wrapped;
+ // Compare `[[Class]]` names.
+ var className = toString.call(a);
+ if (className != toString.call(b)) return false;
+ switch (className) {
+ // Strings, numbers, dates, and booleans are compared by value.
+ case '[object String]':
+ // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+ // equivalent to `new String("5")`.
+ return a == String(b);
+ case '[object Number]':
+ // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+ // other numeric values.
+ return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+ case '[object Date]':
+ case '[object Boolean]':
+ // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+ // millisecond representations. Note that invalid dates with millisecond representations
+ // of `NaN` are not equivalent.
+ return +a == +b;
+ // RegExps are compared by their source patterns and flags.
+ case '[object RegExp]':
+ return a.source == b.source &&
+ a.global == b.global &&
+ a.multiline == b.multiline &&
+ a.ignoreCase == b.ignoreCase;
+ }
+ if (typeof a != 'object' || typeof b != 'object') return false;
+ // Assume equality for cyclic structures. The algorithm for detecting cyclic
+ // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+ var length = aStack.length;
+ while (length--) {
+ // Linear search. Performance is inversely proportional to the number of
+ // unique nested structures.
+ if (aStack[length] == a) return bStack[length] == b;
+ }
+ // Add the first object to the stack of traversed objects.
+ aStack.push(a);
+ bStack.push(b);
+ var size = 0, result = true;
+ // Recursively compare objects and arrays.
+ if (className == '[object Array]') {
+ // Compare array lengths to determine if a deep comparison is necessary.
+ size = a.length;
+ result = size == b.length;
+ if (result) {
+ // Deep compare the contents, ignoring non-numeric properties.
+ while (size--) {
+ if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+ }
+ }
+ } else {
+ // Objects with different constructors are not equivalent, but `Object`s
+ // from different frames are.
+ var aCtor = a.constructor, bCtor = b.constructor;
+ if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+ _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+ return false;
+ }
+ // Deep compare objects.
+ for (var key in a) {
+ if (_.has(a, key)) {
+ // Count the expected number of properties.
+ size++;
+ // Deep compare each member.
+ if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+ }
+ }
+ // Ensure that both objects contain the same number of properties.
+ if (result) {
+ for (key in b) {
+ if (_.has(b, key) && !(size--)) break;
+ }
+ result = !size;
+ }
+ }
+ // Remove the first object from the stack of traversed objects.
+ aStack.pop();
+ bStack.pop();
+ return result;
+ };
+
+ // Perform a deep comparison to check if two objects are equal.
+ _.isEqual = function(a, b) {
+ return eq(a, b, [], []);
+ };
+
+ // Is a given array, string, or object empty?
+ // An "empty" object has no enumerable own-properties.
+ _.isEmpty = function(obj) {
+ if (obj == null) return true;
+ if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+ for (var key in obj) if (_.has(obj, key)) return false;
+ return true;
+ };
+
+ // Is a given value a DOM element?
+ _.isElement = function(obj) {
+ return !!(obj && obj.nodeType === 1);
+ };
+
+ // Is a given value an array?
+ // Delegates to ECMA5's native Array.isArray
+ _.isArray = nativeIsArray || function(obj) {
+ return toString.call(obj) == '[object Array]';
+ };
+
+ // Is a given variable an object?
+ _.isObject = function(obj) {
+ return obj === Object(obj);
+ };
+
+ // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+ each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+ _['is' + name] = function(obj) {
+ return toString.call(obj) == '[object ' + name + ']';
+ };
+ });
+
+ // Define a fallback version of the method in browsers (ahem, IE), where
+ // there isn't any inspectable "Arguments" type.
+ if (!_.isArguments(arguments)) {
+ _.isArguments = function(obj) {
+ return !!(obj && _.has(obj, 'callee'));
+ };
+ }
+
+ // Optimize `isFunction` if appropriate.
+ if (typeof (/./) !== 'function') {
+ _.isFunction = function(obj) {
+ return typeof obj === 'function';
+ };
+ }
+
+ // Is a given object a finite number?
+ _.isFinite = function(obj) {
+ return isFinite(obj) && !isNaN(parseFloat(obj));
+ };
+
+ // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+ _.isNaN = function(obj) {
+ return _.isNumber(obj) && obj != +obj;
+ };
+
+ // Is a given value a boolean?
+ _.isBoolean = function(obj) {
+ return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+ };
+
+ // Is a given value equal to null?
+ _.isNull = function(obj) {
+ return obj === null;
+ };
+
+ // Is a given variable undefined?
+ _.isUndefined = function(obj) {
+ return obj === void 0;
+ };
+
+ // Shortcut function for checking if an object has a given property directly
+ // on itself (in other words, not on a prototype).
+ _.has = function(obj, key) {
+ return hasOwnProperty.call(obj, key);
+ };
+
+ // Utility Functions
+ // -----------------
+
+ // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+ // previous owner. Returns a reference to the Underscore object.
+ _.noConflict = function() {
+ root._ = previousUnderscore;
+ return this;
+ };
+
+ // Keep the identity function around for default iterators.
+ _.identity = function(value) {
+ return value;
+ };
+
+ // Run a function **n** times.
+ _.times = function(n, iterator, context) {
+ var accum = Array(n);
+ for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+ return accum;
+ };
+
+ // Return a random integer between min and max (inclusive).
+ _.random = function(min, max) {
+ if (max == null) {
+ max = min;
+ min = 0;
+ }
+ return min + (0 | Math.random() * (max - min + 1));
+ };
+
+ // List of HTML entities for escaping.
+ var entityMap = {
+ escape: {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": ''',
+ '/': '/'
+ }
+ };
+ entityMap.unescape = _.invert(entityMap.escape);
+
+ // Regexes containing the keys and values listed immediately above.
+ var entityRegexes = {
+ escape: new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+ unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+ };
+
+ // Functions for escaping and unescaping strings to/from HTML interpolation.
+ _.each(['escape', 'unescape'], function(method) {
+ _[method] = function(string) {
+ if (string == null) return '';
+ return ('' + string).replace(entityRegexes[method], function(match) {
+ return entityMap[method][match];
+ });
+ };
+ });
+
+ // If the value of the named property is a function then invoke it;
+ // otherwise, return it.
+ _.result = function(object, property) {
+ if (object == null) return null;
+ var value = object[property];
+ return _.isFunction(value) ? value.call(object) : value;
+ };
+
+ // Add your own custom functions to the Underscore object.
+ _.mixin = function(obj) {
+ each(_.functions(obj), function(name){
+ var func = _[name] = obj[name];
+ _.prototype[name] = function() {
+ var args = [this._wrapped];
+ push.apply(args, arguments);
+ return result.call(this, func.apply(_, args));
+ };
+ });
+ };
+
+ // Generate a unique integer id (unique within the entire client session).
+ // Useful for temporary DOM ids.
+ var idCounter = 0;
+ _.uniqueId = function(prefix) {
+ var id = '' + ++idCounter;
+ return prefix ? prefix + id : id;
+ };
+
+ // By default, Underscore uses ERB-style template delimiters, change the
+ // following template settings to use alternative delimiters.
+ _.templateSettings = {
+ evaluate : /<%([\s\S]+?)%>/g,
+ interpolate : /<%=([\s\S]+?)%>/g,
+ escape : /<%-([\s\S]+?)%>/g
+ };
+
+ // When customizing `templateSettings`, if you don't want to define an
+ // interpolation, evaluation or escaping regex, we need one that is
+ // guaranteed not to match.
+ var noMatch = /(.)^/;
+
+ // Certain characters need to be escaped so that they can be put into a
+ // string literal.
+ var escapes = {
+ "'": "'",
+ '\\': '\\',
+ '\r': 'r',
+ '\n': 'n',
+ '\t': 't',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
+ // JavaScript micro-templating, similar to John Resig's implementation.
+ // Underscore templating handles arbitrary delimiters, preserves whitespace,
+ // and correctly escapes quotes within interpolated code.
+ _.template = function(text, data, settings) {
+ settings = _.defaults({}, settings, _.templateSettings);
+
+ // Combine delimiters into one regular expression via alternation.
+ var matcher = new RegExp([
+ (settings.escape || noMatch).source,
+ (settings.interpolate || noMatch).source,
+ (settings.evaluate || noMatch).source
+ ].join('|') + '|$', 'g');
+
+ // Compile the template source, escaping string literals appropriately.
+ var index = 0;
+ var source = "__p+='";
+ text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+ source += text.slice(index, offset)
+ .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+ if (escape) {
+ source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+ }
+ if (interpolate) {
+ source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+ }
+ if (evaluate) {
+ source += "';\n" + evaluate + "\n__p+='";
+ }
+ index = offset + match.length;
+ return match;
+ });
+ source += "';\n";
+
+ // If a variable is not specified, place data values in local scope.
+ if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+ source = "var __t,__p='',__j=Array.prototype.join," +
+ "print=function(){__p+=__j.call(arguments,'');};\n" +
+ source + "return __p;\n";
+
+ try {
+ var render = new Function(settings.variable || 'obj', '_', source);
+ } catch (e) {
+ e.source = source;
+ throw e;
+ }
+
+ if (data) return render(data, _);
+ var template = function(data) {
+ return render.call(this, data, _);
+ };
+
+ // Provide the compiled function source as a convenience for precompilation.
+ template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+ return template;
+ };
+
+ // Add a "chain" function, which will delegate to the wrapper.
+ _.chain = function(obj) {
+ return _(obj).chain();
+ };
+
+ // OOP
+ // ---------------
+ // If Underscore is called as a function, it returns a wrapped object that
+ // can be used OO-style. This wrapper holds altered versions of all the
+ // underscore functions. Wrapped objects may be chained.
+
+ // Helper function to continue chaining intermediate results.
+ var result = function(obj) {
+ return this._chain ? _(obj).chain() : obj;
+ };
+
+ // Add all of the Underscore functions to the wrapper object.
+ _.mixin(_);
+
+ // Add all mutator Array functions to the wrapper.
+ each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+ var method = ArrayProto[name];
+ _.prototype[name] = function() {
+ var obj = this._wrapped;
+ method.apply(obj, arguments);
+ if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+ return result.call(this, obj);
+ };
+ });
+
+ // Add all accessor Array functions to the wrapper.
+ each(['concat', 'join', 'slice'], function(name) {
+ var method = ArrayProto[name];
+ _.prototype[name] = function() {
+ return result.call(this, method.apply(this._wrapped, arguments));
+ };
+ });
+
+ _.extend(_.prototype, {
+
+ // Start chaining a wrapped Underscore object.
+ chain: function() {
+ this._chain = true;
+ return this;
+ },
+
+ // Extracts the result from a wrapped and chained object.
+ value: function() {
+ return this._wrapped;
+ }
+
+ });
+
+}).call(this);
diff --git a/html/admin/test/runnerJSLint.html b/html/admin/test/runnerJSLint.html
new file mode 100644
index 0000000000..0bc2069ad3
--- /dev/null
+++ b/html/admin/test/runnerJSLint.html
@@ -0,0 +1,86 @@
+
+
+
+
Jasmine Test JSLint
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/html/admin/test/specJSLint/jsLintSpec.js b/html/admin/test/specJSLint/jsLintSpec.js
new file mode 100644
index 0000000000..6392b4abc3
--- /dev/null
+++ b/html/admin/test/specJSLint/jsLintSpec.js
@@ -0,0 +1,68 @@
+describe('JSLint', function () {
+ var options = {},
+ lint = /^\/specJSLint|.jsLintSpec\.js$/;
+
+ function get(path) {
+ path = path + "?" + new Date().getTime();
+
+ var xhr;
+ try {
+ xhr = new jasmine.XmlHttpRequest();
+ xhr.open("GET", path, false);
+ xhr.send(null);
+ } catch (e) {
+ throw new Error("couldn't fetch " + path + ": " + e);
+ }
+ if (xhr.status < 200 || xhr.status > 299) {
+ throw new Error("Could not load '" + path + "'.");
+ }
+
+ return xhr.responseText;
+ }
+
+ describe('checking codeFiles', function() {
+ var files = /^(.*lib\/.*)|(.*Spec\.js)$/;
+
+ _.each(document.getElementsByTagName('script'), function (element) {
+ var script = element.getAttribute('src');
+ if (files.test(script)) {
+ return;
+ }
+ it(script, function () {
+ var self = this;
+ var source = get(script);
+ var result = JSLINT(source, options);
+ _.each(JSLINT.errors, function (error) {
+ self.addMatcherResult(new jasmine.ExpectationResult({
+ passed: false,
+ message: "line " + error.line + ' - ' + error.reason + ' - ' + error.evidence
+ }));
+ });
+ expect(true).toBe(true); // force spec to show up if there are no errors
+ });
+ });
+ });
+
+ describe('checking specFiles', function() {
+ var files = /^\/spec*|.*Spec\.js$/;
+
+ _.each(document.getElementsByTagName('script'), function (element) {
+ var script = element.getAttribute('src');
+ if (!files.test(script) || lint.test(script)) {
+ return;
+ }
+ it(script, function () {
+ var self = this;
+ var source = get(script);
+ var result = JSLINT(source, options);
+ _.each(JSLINT.errors, function (error) {
+ self.addMatcherResult(new jasmine.ExpectationResult({
+ passed: false,
+ message: "line " + error.line + ' - ' + error.reason + ' - ' + error.evidence
+ }));
+ });
+ expect(true).toBe(true); // force spec to show up if there are no errors
+ });
+ });
+ });
+});
\ No newline at end of file
Add Collection
'
]);
});
- $(".prettify").snippet("javascript", {style: "nedit", menu: false, startText: false, transparent: true, showNum: false});
-/* $(".prettify").tooltip({
- html: true,
- placement: "top"
- });*/
+ $(".prettify").snippet("javascript", {
+ style: "nedit",
+ menu: false,
+ startText: false,
+ transparent: true,
+ showNum: false
+ });
this.totalPages = window.arangoDocumentsStore.totalPages;
this.currentPage = window.arangoDocumentsStore.currentPage;
this.documentsCount = window.arangoDocumentsStore.documentsCount;
- if (this.documentsCount === 0) {
- }
- else {
+ if (this.documentsCount !== 0) {
$('#documentsStatus').html(
'Showing Page '+this.currentPage+' of '+this.totalPages+
', '+this.documentsCount+' entries'
@@ -305,13 +309,19 @@ var documentsView = Backbone.View.extend({
}
};
target.pagination(options);
- $('#documentsToolbarF').prepend('');
- $('#documentsToolbarF').append('');
+ $('#documentsToolbarF').prepend(
+ '');
+ $('#documentsToolbarF').append(
+ '');
var total = $('#totalDocuments');
if (total.length > 0) {
total.html("Total: " + this.documentsCount + " documents");
} else {
- $('#documentsToolbarFL').append('Total: ' + this.documentsCount + ' document(s) ');
+ $('#documentsToolbarFL').append(
+ 'Total: ' + this.documentsCount + ' document(s) '
+ );
}
},
breadcrumb: function () {
@@ -331,7 +341,8 @@ var documentsView = Backbone.View.extend({
return this.escaped(string);
},
escaped: function (value) {
- return value.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'");
+ return value.replace(/&/g, "&").replace(//g, ">")
+ .replace(/"/g, """).replace(/'/g, "'");
}
});
diff --git a/html/admin/js/views/footerView.js b/html/admin/js/views/footerView.js
index 332e40ac7c..c5512d5e50 100644
--- a/html/admin/js/views/footerView.js
+++ b/html/admin/js/views/footerView.js
@@ -1,3 +1,6 @@
+/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true */
+/*global require, exports, Backbone, EJS, $*/
+
var footerView = Backbone.View.extend({
el: '.footer',
init: function () {
diff --git a/html/admin/js/views/logsView.js b/html/admin/js/views/logsView.js
index eb416f5ffc..6f024760bc 100644
--- a/html/admin/js/views/logsView.js
+++ b/html/admin/js/views/logsView.js
@@ -1,3 +1,6 @@
+/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true */
+/*global require, exports, Backbone, EJS, $, window*/
+
var logsView = Backbone.View.extend({
el: '#content',
offset: 0,
@@ -21,12 +24,10 @@ var logsView = Backbone.View.extend({
"click #logTableID_first" : "firstTable",
"click #logTableID_last" : "lastTable",
"click #logTableID_prev" : "prevTable",
- "click #logTableID_next" : "nextTable",
+ "click #logTableID_next" : "nextTable"
},
firstTable: function () {
- if (this.offset == 0) {
- }
- else {
+ if (this.offset !== 0) {
this.offset = 0;
this.page = 1;
this.clearTable();
@@ -34,9 +35,7 @@ var logsView = Backbone.View.extend({
}
},
lastTable: function () {
- if (this.page == this.totalPages) {
- }
- else {
+ if (this.page !== this.totalPages) {
this.totalPages = Math.ceil(this.totalAmount / this.size);
this.page = this.totalPages;
this.offset = (this.totalPages * this.size) - this.size;
@@ -45,9 +44,7 @@ var logsView = Backbone.View.extend({
}
},
prevTable: function () {
- if (this.offset == 0) {
- }
- else {
+ if (this.offset !== 0) {
this.offset = this.offset - this.size;
this.page = this.page - 1;
this.clearTable();
@@ -55,9 +52,7 @@ var logsView = Backbone.View.extend({
}
},
nextTable: function () {
- if (this.page == this.totalPages) {
- }
- else {
+ if (this.page !== this.totalPages) {
this.page = this.page + 1;
this.offset = this.offset + this.size;
this.clearTable();
@@ -160,15 +155,21 @@ var logsView = Backbone.View.extend({
}
};
target.pagination(options);
- $('#logtestdiv').prepend('');
- $('#logtestdiv').append('');
+ $('#logtestdiv').prepend(
+ ''
+ );
+ $('#logtestdiv').append(
+ ''
+ );
},
drawTable: function () {
var self = this;
function format (dt) {
var pad = function (n) {
- return n < 10 ? '0' + n : n
+ return n < 10 ? '0' + n : n;
};
return dt.getUTCFullYear() + '-'
@@ -197,10 +198,22 @@ var logsView = Backbone.View.extend({
$('#'+this.table).dataTable().fnClearTable();
},
convertLogStatus: function (status) {
- if (status === 1) { return "Error" ;}
- else if (status === 2) { return "Warning" ;}
- else if (status === 3) { return "Info" ;}
- else if (status === 4) { return "Debug" ;}
- else { return "Unknown";}
+ var returnString;
+ if (status === 1) {
+ returnString = "Error";
+ }
+ else if (status === 2) {
+ returnString = "Warning";
+ }
+ else if (status === 3) {
+ returnString = "Info";
+ }
+ else if (status === 4) {
+ returnString = "Debug";
+ }
+ else {
+ returnString = "Unknown";
+ }
+ return returnString;
}
});
diff --git a/html/admin/js/views/navigationView.js b/html/admin/js/views/navigationView.js
index 6b8509908e..6da7282816 100644
--- a/html/admin/js/views/navigationView.js
+++ b/html/admin/js/views/navigationView.js
@@ -1,3 +1,6 @@
+/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true */
+/*global require, exports, Backbone, EJS, $*/
+
var navigationView = Backbone.View.extend({
el: '.header',
init: function () {
diff --git a/html/admin/js/views/newCollectionView.js b/html/admin/js/views/newCollectionView.js
index 1f4889a091..33542bcf3e 100644
--- a/html/admin/js/views/newCollectionView.js
+++ b/html/admin/js/views/newCollectionView.js
@@ -1,3 +1,6 @@
+/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true */
+/*global require, exports, Backbone, EJS, $, window, arangoHelper*/
+
var newCollectionView = Backbone.View.extend({
el: '#modalPlaceholder',
initialize: function () {
@@ -32,7 +35,7 @@ var newCollectionView = Backbone.View.extend({
},
listenKey: function(e) {
- if (e.keyCode == 13) {
+ if (e.keyCode === 13) {
this.saveNewCollection();
}
},
@@ -41,7 +44,6 @@ var newCollectionView = Backbone.View.extend({
},
saveNewCollection: function(a) {
- //TODO: other solution
if (window.location.hash !== '#new') {
return;
}
@@ -53,9 +55,10 @@ var newCollectionView = Backbone.View.extend({
var collType = $('#new-collection-type').val();
var collSync = $('#new-collection-sync').val();
var isSystem = (collName.substr(0, 1) === '_');
- var wfs = (collSync == "true");
+ var wfs = (collSync === "true");
+ var journalSizeString;
- if (collSize == '') {
+ if (collSize === '') {
journalSizeString = '';
}
else {
@@ -68,12 +71,14 @@ var newCollectionView = Backbone.View.extend({
return 0;
}
}
- if (collName == '') {
+ if (collName === '') {
arangoHelper.arangoError('No collection name entered!');
return 0;
}
- var returnobj = window.arangoCollectionsStore.newCollection(collName, wfs, isSystem, journalSizeString, collType);
+ var returnobj = window.arangoCollectionsStore.newCollection(
+ collName, wfs, isSystem, journalSizeString, collType
+ );
if (returnobj.status === true) {
self.hidden();
$("#add-collection").modal('hide');
diff --git a/html/admin/js/views/queryView.js b/html/admin/js/views/queryView.js
index 05ce8cbc4b..7a70796371 100644
--- a/html/admin/js/views/queryView.js
+++ b/html/admin/js/views/queryView.js
@@ -1,3 +1,6 @@
+/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true */
+/*global require, exports, Backbone, EJS, $, localStorage, ace, Storage, window, arangoHelper*/
+
var queryView = Backbone.View.extend({
el: '#content',
initialize: function () {
@@ -7,7 +10,7 @@ var queryView = Backbone.View.extend({
events: {
'click #submitQueryIcon' : 'submitQuery',
'click #submitQueryButton' : 'submitQuery',
- 'click .clearicon': 'clearOutput',
+ 'click .clearicon': 'clearOutput'
},
clearOutput: function() {
$('#queryOutput').empty();
@@ -50,7 +53,7 @@ var queryView = Backbone.View.extend({
$('#aqlEditor .ace_text-input').focus();
$.gritter.removeAll();
- if(typeof(Storage)!=="undefined") {
+ if(typeof Storage) {
var queryContent = localStorage.getItem("queryContent");
var queryOutput = localStorage.getItem("queryOutput");
editor.setValue(queryContent);
@@ -80,8 +83,8 @@ var queryView = Backbone.View.extend({
contentType: "application/json",
processData: false,
success: function(data) {
- editor2.setValue(self.FormatJSON(data.result));
- if(typeof(Storage) !== "undefined") {
+ editor2.setValue(arangoHelper.FormatJSON(data.result));
+ if(typeof Storage) {
localStorage.setItem("queryContent", editor.getValue());
localStorage.setItem("queryOutput", editor2.getValue());
}
@@ -91,7 +94,7 @@ var queryView = Backbone.View.extend({
var temp = JSON.parse(data.responseText);
editor2.setValue('[' + temp.errorNum + '] ' + temp.errorMessage);
- if(typeof(Storage) !== "undefined") {
+ if(typeof Storage) {
localStorage.setItem("queryContent", editor.getValue());
localStorage.setItem("queryOutput", editor2.getValue());
}
@@ -103,87 +106,6 @@ var queryView = Backbone.View.extend({
});
editor2.resize();
- },
- FormatJSON: function(oData, sIndent) {
- var self = this;
- if (arguments.length < 2) {
- var sIndent = "";
- }
- var sIndentStyle = " ";
- var sDataType = self.RealTypeOf(oData);
-
- if (sDataType == "array") {
- if (oData.length == 0) {
- return "[]";
- }
- var sHTML = "[";
- } else {
- var iCount = 0;
- $.each(oData, function() {
- iCount++;
- return;
- });
- if (iCount == 0) { // object is empty
- return "{}";
- }
- var sHTML = "{";
- }
-
- // loop through items
- var iCount = 0;
- $.each(oData, function(sKey, vValue) {
- if (iCount > 0) {
- sHTML += ",";
- }
- if (sDataType == "array") {
- sHTML += ("\n" + sIndent + sIndentStyle);
- } else {
- sHTML += ("\n" + sIndent + sIndentStyle + JSON.stringify(sKey) + ": ");
- }
-
- // display relevant data type
- switch (self.RealTypeOf(vValue)) {
- case "array":
- case "object":
- sHTML += self.FormatJSON(vValue, (sIndent + sIndentStyle));
- break;
- case "boolean":
- case "number":
- sHTML += vValue.toString();
- break;
- case "null":
- sHTML += "null";
- break;
- case "string":
- sHTML += "\"" + vValue.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"";
- break;
- default:
- sHTML += ("TYPEOF: " + typeof(vValue));
- }
-
- // loop
- iCount++;
- });
-
- // close object
- if (sDataType == "array") {
- sHTML += ("\n" + sIndent + "]");
- } else {
- sHTML += ("\n" + sIndent + "}");
- }
-
- // return
- return sHTML;
- },
- RealTypeOf: function(v) {
- if (typeof(v) == "object") {
- if (v === null) return "null";
- if (v.constructor == (new Array).constructor) return "array";
- if (v.constructor == (new Date).constructor) return "date";
- if (v.constructor == (new RegExp).constructor) return "regex";
- return "object";
- }
- return typeof(v);
}
});
diff --git a/html/admin/js/views/shellView.js b/html/admin/js/views/shellView.js
index b11b380361..710dfdbd52 100644
--- a/html/admin/js/views/shellView.js
+++ b/html/admin/js/views/shellView.js
@@ -1,3 +1,6 @@
+/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true, evil: true, es5:true */
+/*global require, exports, Backbone, EJS, $, window, ace, jqconsole, handler, help, location*/
+
var shellView = Backbone.View.extend({
el: '#content',
events: {
@@ -28,7 +31,7 @@ var shellView = Backbone.View.extend({
},
renderEditor: function () {
var editor = ace.edit("editor");
- editor.resize()
+ editor.resize();
},
editor: function () {
var editor = ace.edit("editor");
@@ -93,13 +96,13 @@ var shellView = Backbone.View.extend({
jqconsole.Prompt(true, handler, function(command) {
// Continue line if can't compile the command.
try {
- Function(command);
- } catch (e) {
+ var test = new Function(command);
+ }
+ catch (e) {
if (/[\[\{\(]$/.test(command)) {
return 1;
- } else {
- return 0;
}
+ return 0;
}
return false;
});
diff --git a/html/admin/test/dummy.html b/html/admin/test/dummy.html
new file mode 100644
index 0000000000..ea6fc78112
--- /dev/null
+++ b/html/admin/test/dummy.html
@@ -0,0 +1,74 @@
+
+
+
+