| 1 | /*!
|
| 2 | * Snakeskin
|
| 3 | * https://github.com/SnakeskinTpl/Snakeskin
|
| 4 | *
|
| 5 | * Released under the MIT license
|
| 6 | * https://github.com/SnakeskinTpl/Snakeskin/blob/master/LICENSE
|
| 7 | */
|
| 8 |
|
| 9 | // EXTERNS:
|
| 10 |
|
| 11 | /** @const */
|
| 12 | var Snakeskin = {
|
| 13 | /** @type {?string} */
|
| 14 | UID: null,
|
| 15 |
|
| 16 | /** @type {!Array} */
|
| 17 | VERSION: [],
|
| 18 |
|
| 19 | /** @const */
|
| 20 | Filters: {},
|
| 21 |
|
| 22 | /** @const */
|
| 23 | Vars: {},
|
| 24 |
|
| 25 | /** @const */
|
| 26 | LocalVars: {},
|
| 27 |
|
| 28 | /** @const */
|
| 29 | cache: {},
|
| 30 |
|
| 31 | /**
|
| 32 | * @abstract
|
| 33 | * @param {(Element|string)} src
|
| 34 | * @param {?$$SnakeskinParams=} [opt_params]
|
| 35 | * @param {?$$SnakeskinInfoParams=} [opt_info]
|
| 36 | * @return {(string|boolean|null)}
|
| 37 | */
|
| 38 | compile: function (src, opt_params, opt_info) {}
|
| 39 | };
|
| 40 |
|
| 41 | /**
|
| 42 | * @abstract
|
| 43 | * @param {string} name
|
| 44 | * @return {string}
|
| 45 | */
|
| 46 | Snakeskin.group = function (name) {};
|
| 47 |
|
| 48 | /**
|
| 49 | * @typedef {{
|
| 50 | * deferInit: (?boolean|undefined),
|
| 51 | * async: (?boolean|undefined),
|
| 52 | * generator: (?boolean|undefined),
|
| 53 | * notEmpty: (?boolean|undefined),
|
| 54 | * alias: (?boolean|undefined),
|
| 55 | * group: (Array|string|undefined),
|
| 56 | * renderModesBlacklist: (Array|string|undefined),
|
| 57 | * renderModesWhitelist: (Array|string|undefined),
|
| 58 | * placement: (Array|string|undefined),
|
| 59 | * ancestorsBlacklist: (Array|string|undefined),
|
| 60 | * ancestorsWhitelist: (Array|string|undefined),
|
| 61 | * with: (Array|string|undefined),
|
| 62 | * parents: (Array|string|undefined),
|
| 63 | * endsWith: (Array|string|undefined),
|
| 64 | * endFor: (Array|string|undefined),
|
| 65 | * trim: ({left: boolean, right: boolean}|boolean|undefined),
|
| 66 | * logic: (?boolean|undefined),
|
| 67 | * text: (?boolean|undefined),
|
| 68 | * block: (?boolean|undefined),
|
| 69 | * selfInclude: (?boolean|undefined),
|
| 70 | * interpolation: (?boolean|undefined),
|
| 71 | * selfThis: (?boolean|undefined),
|
| 72 | * shorthands: (Object<string, (string|function(string): string)>|undefined)
|
| 73 | * }}
|
| 74 | */
|
| 75 | var $$SnakeskinAddDirectiveParams;
|
| 76 |
|
| 77 | /** @type {?} */
|
| 78 | var deferInit;
|
| 79 |
|
| 80 | /** @type {?} */
|
| 81 | var generator;
|
| 82 |
|
| 83 | /** @type {?} */
|
| 84 | var notEmpty;
|
| 85 |
|
| 86 | /** @type {?} */
|
| 87 | var alias;
|
| 88 |
|
| 89 | /** @type {?} */
|
| 90 | var group;
|
| 91 |
|
| 92 | /** @type {?} */
|
| 93 | var renderModesBlacklist;
|
| 94 |
|
| 95 | /** @type {?} */
|
| 96 | var renderModesWhitelist;
|
| 97 |
|
| 98 | /** @type {?} */
|
| 99 | var placement;
|
| 100 |
|
| 101 | /** @type {?} */
|
| 102 | var ancestorsBlacklist;
|
| 103 |
|
| 104 | /** @type {?} */
|
| 105 | var ancestorsWhitelist;
|
| 106 |
|
| 107 | /** @type {?} */
|
| 108 | var parents;
|
| 109 |
|
| 110 | /** @type {?} */
|
| 111 | var endsWith;
|
| 112 |
|
| 113 | /** @type {?} */
|
| 114 | var endFor;
|
| 115 |
|
| 116 | /** @type {?} */
|
| 117 | var trim;
|
| 118 |
|
| 119 | /** @type {?} */
|
| 120 | var logic;
|
| 121 |
|
| 122 | /** @type {?} */
|
| 123 | var text;
|
| 124 |
|
| 125 | /** @type {?} */
|
| 126 | var block;
|
| 127 |
|
| 128 | /** @type {?} */
|
| 129 | var selfInclude;
|
| 130 |
|
| 131 | /** @type {?} */
|
| 132 | var selfThis;
|
| 133 |
|
| 134 | /** @type {?} */
|
| 135 | var shorthands;
|
| 136 |
|
| 137 | /**
|
| 138 | * @abstract
|
| 139 | * @param {string} name
|
| 140 | * @param {$$SnakeskinAddDirectiveParams} params
|
| 141 | * @param {function(this:$$SnakeskinParser, string, number, string, string, (boolean|number))=} opt_constr
|
| 142 | * @param {function(this:$$SnakeskinParser, string, number, string, string, (boolean|number))=} opt_destruct
|
| 143 | */
|
| 144 | Snakeskin.addDirective = function (name, params, opt_constr, opt_destruct) {};
|
| 145 |
|
| 146 | /**
|
| 147 | * @typedef {{
|
| 148 | * file: (?string|undefined),
|
| 149 | * line: (?number|undefined),
|
| 150 | * node: (Element|undefined),
|
| 151 | * template: (?string|undefined)
|
| 152 | * }}
|
| 153 | */
|
| 154 | var $$SnakeskinInfoParams;
|
| 155 |
|
| 156 | /** @type {?} */
|
| 157 | var file;
|
| 158 |
|
| 159 | /** @type {?} */
|
| 160 | var line;
|
| 161 |
|
| 162 | /** @type {?} */
|
| 163 | var node;
|
| 164 |
|
| 165 | /** @type {?} */
|
| 166 | var template;
|
| 167 |
|
| 168 | /**
|
| 169 | * @typedef {{
|
| 170 | * cache: (?boolean|undefined),
|
| 171 | * getCacheKey: (?boolean|undefined),
|
| 172 | * context: (Object|undefined),
|
| 173 | * babel: (Array|undefined),
|
| 174 | * vars: (Object|undefined),
|
| 175 | * onError: (?function(!Error)|undefined),
|
| 176 | * throws: (?boolean|undefined),
|
| 177 | * debug: (Object|undefined),
|
| 178 | * pack: (?boolean|undefined),
|
| 179 | * module: (?string|undefined),
|
| 180 | * moduleId: (?string|undefined),
|
| 181 | * moduleName: (?string|undefined),
|
| 182 | * useStrict: (?boolean|undefined),
|
| 183 | * prettyPrint: (?boolean|undefined),
|
| 184 | * literalBounds: (Array<string>|undefined),
|
| 185 | * attrLiteralBounds: (Array<string>|undefined),
|
| 186 | * bemFilter: (?string|undefined),
|
| 187 | * filters: (Object|undefined),
|
| 188 | * localization: (?boolean|undefined),
|
| 189 | * i18nFn: (?string|undefined),
|
| 190 | * i18nFnOptions: (?string|undefined),
|
| 191 | * language: (Object|undefined),
|
| 192 | * words: (Object|undefined),
|
| 193 | * ignore: (RegExp|undefined),
|
| 194 | * tolerateWhitespaces: (?boolean|undefined),
|
| 195 | * eol: (?string|undefined),
|
| 196 | * doctype: (?string|undefined),
|
| 197 | * renderAs: (?string|undefined),
|
| 198 | * renderMode: (?string|undefined)
|
| 199 | * }}
|
| 200 | */
|
| 201 | var $$SnakeskinParams;
|
| 202 |
|
| 203 | /** @type {?} */
|
| 204 | var cache;
|
| 205 |
|
| 206 | /** @type {?} */
|
| 207 | var getCacheKey;
|
| 208 |
|
| 209 | /** @type {?} */
|
| 210 | var context;
|
| 211 |
|
| 212 | /** @type {?} */
|
| 213 | var vars;
|
| 214 |
|
| 215 | /** @type {?} */
|
| 216 | var onError;
|
| 217 |
|
| 218 | /** @type {?} */
|
| 219 | var throws;
|
| 220 |
|
| 221 | /** @type {?} */
|
| 222 | var debug;
|
| 223 |
|
| 224 | /** @type {?} */
|
| 225 | var pack;
|
| 226 |
|
| 227 | /** @type {?} */
|
| 228 | var moduleId;
|
| 229 |
|
| 230 | /** @type {?} */
|
| 231 | var moduleName;
|
| 232 |
|
| 233 | /** @type {?} */
|
| 234 | var useStrict;
|
| 235 |
|
| 236 | /** @type {?} */
|
| 237 | var prettyPrint;
|
| 238 |
|
| 239 | /** @type {?} */
|
| 240 | var literalBounds;
|
| 241 |
|
| 242 | /** @type {?} */
|
| 243 | var attrLiteralBounds;
|
| 244 |
|
| 245 | /** @type {?} */
|
| 246 | var bemFilter;
|
| 247 |
|
| 248 | /** @type {?} */
|
| 249 | var filters;
|
| 250 |
|
| 251 | /** @type {?} */
|
| 252 | var localization;
|
| 253 |
|
| 254 | /** @type {?} */
|
| 255 | var i18nFn;
|
| 256 |
|
| 257 | /** @type {?} */
|
| 258 | var i18nFnOptions;
|
| 259 |
|
| 260 | /** @type {?} */
|
| 261 | var language;
|
| 262 |
|
| 263 | /** @type {?} */
|
| 264 | var words;
|
| 265 |
|
| 266 | /** @type {?} */
|
| 267 | var ignore;
|
| 268 |
|
| 269 | /** @type {?} */
|
| 270 | var tolerateWhitespaces;
|
| 271 |
|
| 272 | /** @type {?} */
|
| 273 | var eol;
|
| 274 |
|
| 275 | /** @type {?} */
|
| 276 | var renderAs;
|
| 277 |
|
| 278 | /** @type {?} */
|
| 279 | var renderMode;
|
| 280 |
|
| 281 | /** @type {?} */
|
| 282 | var HTMLObject;
|
| 283 |
|
| 284 | /** @type {?} */
|
| 285 | var StringBuffer;
|
| 286 |
|
| 287 | /** @type {?} */
|
| 288 | var length;
|
| 289 |
|
| 290 | /** @type {?} */
|
| 291 | var textContent;
|
| 292 |
|
| 293 | /** @type {?} */
|
| 294 | var appendChild;
|
| 295 |
|
| 296 | /** @type {?} */
|
| 297 | var setAttribute;
|
| 298 |
|
| 299 | /** @type {?} */
|
| 300 | var include;
|
| 301 |
|
| 302 | /** @type {?} */
|
| 303 | var toObj;
|
| 304 |
|
| 305 | /** @type {?} */
|
| 306 | var safe;
|
| 307 |
|
| 308 | /** @type {?} */
|
| 309 | var bind;
|
| 310 |
|
| 311 | /** @type {?} */
|
| 312 | var test;
|
| 313 |
|
| 314 | /** @const */
|
| 315 | Snakeskin.inlineTags = {};
|
| 316 |
|
| 317 | /**
|
| 318 | * @abstract
|
| 319 | * @param {!Object} filters
|
| 320 | * @param {?string=} [opt_namespace]
|
| 321 | * @return {!Object}
|
| 322 | */
|
| 323 | Snakeskin.importFilters = function (filters, opt_namespace) {};
|
| 324 |
|
| 325 | /**
|
| 326 | * @abstract
|
| 327 | * @param {(string|!Function)} filter
|
| 328 | * @param {Object} params
|
| 329 | * @return {!Function}
|
| 330 | */
|
| 331 | Snakeskin.setFilterParams = function (filter, params) {};
|
| 332 |
|
| 333 | /**
|
| 334 | * @param {(Array|Object|undefined)} obj
|
| 335 | * @param {(
|
| 336 | * function(?, ?, !Array, {isFirst: boolean, isLast: boolean, length: number})|
|
| 337 | * function(?, ?, !Object, {i: number, isFirst: boolean, isLast: boolean, length: number})
|
| 338 | * )} callback - callback function
|
| 339 | */
|
| 340 | Snakeskin.forEach = function (obj, callback) {};
|
| 341 |
|
| 342 | /**
|
| 343 | * @param {(Object|undefined)} obj
|
| 344 | * @param {function(?, string, !Object, {i: number, isFirst: boolean, isLast: boolean, length: number})} callback
|
| 345 | */
|
| 346 | Snakeskin.forIn = function (obj, callback) {};
|
| 347 |
|
| 348 | /**
|
| 349 | * @param {!Array<!Function>} decorators
|
| 350 | * @param {!Function} fn
|
| 351 | * @return {!Function}
|
| 352 | */
|
| 353 | Snakeskin.decorate = function (decorators, fn) {};
|
| 354 |
|
| 355 | ;
|
| 356 |
|
| 357 | /**
|
| 358 | * @param {string} str
|
| 359 | * @return {!Array<string>}
|
| 360 | */
|
| 361 | $$SnakeskinParser.prototype.getFnArgs = function (str) {};
|
| 362 |
|
| 363 | /**
|
| 364 | * @typedef {{
|
| 365 | * dir: (string|undefined),
|
| 366 | * tplName: (string|undefined),
|
| 367 | * parentTplName: (string|undefined),
|
| 368 | * fnName: (string|undefined)
|
| 369 | * }}
|
| 370 | */
|
| 371 | var $$SnakeskinParserDeclFnArgsParams;
|
| 372 |
|
| 373 | /** @typedef {{decl: string, def: string, list: !Array, isCallable, scope: (string|undefined)}} */
|
| 374 | var $$SnakeskinParserDeclFnArgsResult;
|
| 375 |
|
| 376 | /**
|
| 377 | * @param {string} str
|
| 378 | * @param {?$$SnakeskinParserDeclFnArgsParams=} [opt_params]
|
| 379 | * @return {$$SnakeskinParserDeclFnArgsResult}
|
| 380 | */
|
| 381 | $$SnakeskinParser.prototype.declFnArgs = function (str, opt_params) {};
|
| 382 |
|
| 383 |
|
| 384 | /**
|
| 385 | * @param {string} str
|
| 386 | * @return {string}
|
| 387 | */
|
| 388 | $$SnakeskinParser.prototype.getXMLAttrsDecl = function (str) {};
|
| 389 |
|
| 390 | /**
|
| 391 | * @return {string}
|
| 392 | */
|
| 393 | $$SnakeskinParser.prototype.getXMLAttrsDeclStart = function () {};
|
| 394 |
|
| 395 | /**
|
| 396 | * @param {string} str
|
| 397 | * @return {string}
|
| 398 | */
|
| 399 | $$SnakeskinParser.prototype.getXMLAttrsDeclBody = function (str) {};
|
| 400 |
|
| 401 | /**
|
| 402 | * @return {string}
|
| 403 | */
|
| 404 | $$SnakeskinParser.prototype.getXMLAttrsDeclEnd = function () {};
|
| 405 |
|
| 406 | /** @typedef {{attr: string, group: (string|undefined), separator: (string|undefined)}} */
|
| 407 | var $$SnakeskinParserGetXMLAttrDeclParams;
|
| 408 |
|
| 409 | /** @type {?} */
|
| 410 | var attr;
|
| 411 |
|
| 412 | /** @type {?} */
|
| 413 | var separator;
|
| 414 |
|
| 415 | /**
|
| 416 | * @param {$$SnakeskinParserGetXMLAttrDeclParams} params
|
| 417 | * @return {string}
|
| 418 | */
|
| 419 | $$SnakeskinParser.prototype.getXMLAttrDecl = function (params) {};
|
| 420 |
|
| 421 | /**
|
| 422 | * @param {string} str
|
| 423 | * @return {!Array<$$SnakeskinParserGetXMLAttrDeclParams>}
|
| 424 | */
|
| 425 | $$SnakeskinParser.prototype.splitXMLAttrGroup = function (str) {};
|
| 426 |
|
| 427 | /**
|
| 428 | * @typedef {{
|
| 429 | * throws: boolean,
|
| 430 | * onError: (?function(!Error)|undefined),
|
| 431 | * pack: boolean,
|
| 432 | * module: string,
|
| 433 | * moduleId: (?string|undefined),
|
| 434 | * moduleName: (?string|undefined),
|
| 435 | * useStrict: boolean,
|
| 436 | * literalBounds: !Array<string>,
|
| 437 | * attrLiteralBounds: (Array<string>|undefined),
|
| 438 | * bemFilter: string,
|
| 439 | * filters: (!Array),
|
| 440 | * localization: boolean,
|
| 441 | * i18nFn: string,
|
| 442 | * i18nFnOptions: (?string|undefined),
|
| 443 | * language: (Object|undefined),
|
| 444 | * words: (Object|undefined),
|
| 445 | * ignore: (RegExp|undefined),
|
| 446 | * tolerateWhitespaces: boolean,
|
| 447 | * eol: string,
|
| 448 | * doctype: string,
|
| 449 | * renderAs: (?string|undefined),
|
| 450 | * renderMode: string,
|
| 451 | * info: {file, line, node, template}
|
| 452 | * }}
|
| 453 | */
|
| 454 | var $$SnakeskinParserParams;
|
| 455 |
|
| 456 | /** @type {?} */
|
| 457 | var info;
|
| 458 |
|
| 459 | /**
|
| 460 | * @interface
|
| 461 | * @param {string} src
|
| 462 | * @param {$$SnakeskinParserParams} params
|
| 463 | */
|
| 464 | function $$SnakeskinParser(src, params) {}
|
| 465 |
|
| 466 | /** @type {boolean} */
|
| 467 | $$SnakeskinParser.prototype.throws;
|
| 468 |
|
| 469 | /** @type {(?function(!Error)|undefined)} */
|
| 470 | $$SnakeskinParser.prototype.onError;
|
| 471 |
|
| 472 | /** @type {boolean} */
|
| 473 | $$SnakeskinParser.prototype.pack;
|
| 474 |
|
| 475 | /** @type {string} */
|
| 476 | $$SnakeskinParser.prototype.module;
|
| 477 |
|
| 478 | /** @type {(?string|undefined)} */
|
| 479 | $$SnakeskinParser.prototype.moduleId;
|
| 480 |
|
| 481 | /** @type {(?string|undefined)} */
|
| 482 | $$SnakeskinParser.prototype.moduleName;
|
| 483 |
|
| 484 | /** @type {boolean} */
|
| 485 | $$SnakeskinParser.prototype.useStrict;
|
| 486 |
|
| 487 | /** @type {!Array<string>} */
|
| 488 | $$SnakeskinParser.prototype.literalBounds;
|
| 489 |
|
| 490 | /** @type {(Array<string>|undefined)} */
|
| 491 | $$SnakeskinParser.prototype.attrLiteralBounds;
|
| 492 |
|
| 493 | /** @type {string} */
|
| 494 | $$SnakeskinParser.prototype.bemFilter;
|
| 495 |
|
| 496 | /** @type {!Array} */
|
| 497 | $$SnakeskinParser.prototype.filters;
|
| 498 |
|
| 499 | /** @type {boolean} */
|
| 500 | $$SnakeskinParser.prototype.localization;
|
| 501 |
|
| 502 | /** @type {string} */
|
| 503 | $$SnakeskinParser.prototype.i18nFn;
|
| 504 |
|
| 505 | /** @type {(?string|undefined)} */
|
| 506 | $$SnakeskinParser.prototype.i18nFnOptions;
|
| 507 |
|
| 508 | /** @type {(Object|undefined)} */
|
| 509 | $$SnakeskinParser.prototype.language;
|
| 510 |
|
| 511 | /** @type {(Object|undefined)} */
|
| 512 | $$SnakeskinParser.prototype.words;
|
| 513 |
|
| 514 | /** @type {(RegExp|undefined)} */
|
| 515 | $$SnakeskinParser.prototype.ignore;
|
| 516 |
|
| 517 | /** @type {boolean} */
|
| 518 | $$SnakeskinParser.prototype.tolerateWhitespaces;
|
| 519 |
|
| 520 | /** @type {string} */
|
| 521 | $$SnakeskinParser.prototype.eol;
|
| 522 |
|
| 523 | /** @type {(?string|undefined)} */
|
| 524 | $$SnakeskinParser.prototype.renderAs;
|
| 525 |
|
| 526 | /** @type {string} */
|
| 527 | $$SnakeskinParser.prototype.renderMode;
|
| 528 |
|
| 529 | /** @type {{file, line, node, template}} */
|
| 530 | $$SnakeskinParser.prototype.info;
|
| 531 |
|
| 532 | /** @type {!Array<!Object>} */
|
| 533 | $$SnakeskinParser.prototype.params;
|
| 534 |
|
| 535 | /** @type {(boolean|number)} */
|
| 536 | $$SnakeskinParser.prototype.needPrfx;
|
| 537 |
|
| 538 | /** @type {!Array} */
|
| 539 | $$SnakeskinParser.prototype.lines;
|
| 540 |
|
| 541 | /** @type {!Array} */
|
| 542 | $$SnakeskinParser.prototype.errors;
|
| 543 |
|
| 544 | /** @type {boolean} */
|
| 545 | $$SnakeskinParser.prototype.break;
|
| 546 |
|
| 547 | /** @type {Array} */
|
| 548 | $$SnakeskinParser.prototype.consts;
|
| 549 |
|
| 550 | /** @type {!Object} */
|
| 551 | $$SnakeskinParser.prototype.vars;
|
| 552 |
|
| 553 | /** @type {!Array<string>} */
|
| 554 | $$SnakeskinParser.prototype.scope;
|
| 555 |
|
| 556 | /** @type {?string} */
|
| 557 | $$SnakeskinParser.prototype.name;
|
| 558 |
|
| 559 | /** @type {!Array<boolean>} */
|
| 560 | $$SnakeskinParser.prototype.inline;
|
| 561 |
|
| 562 | /** @type {boolean} */
|
| 563 | $$SnakeskinParser.prototype.text;
|
| 564 |
|
| 565 | /** @type {!Object<{files: Array}>} */
|
| 566 | $$SnakeskinParser.prototype.namespaces;
|
| 567 |
|
| 568 | /** @type {!Object<{file, renderAs}>} */
|
| 569 | $$SnakeskinParser.prototype.templates;
|
| 570 |
|
| 571 | /** @type {?string} */
|
| 572 | $$SnakeskinParser.prototype.tplName;
|
| 573 |
|
| 574 | /** @type {?string} */
|
| 575 | $$SnakeskinParser.prototype.parentTplName;
|
| 576 |
|
| 577 | /** @type {string} */
|
| 578 | $$SnakeskinParser.prototype.doctype;
|
| 579 |
|
| 580 | /** @type {?boolean} */
|
| 581 | $$SnakeskinParser.prototype.generator;
|
| 582 |
|
| 583 | /** @type {number} */
|
| 584 | $$SnakeskinParser.prototype.deferReturn;
|
| 585 |
|
| 586 | /** @type {number} */
|
| 587 | $$SnakeskinParser.prototype.startTemplateI;
|
| 588 |
|
| 589 | /** @type {?number} */
|
| 590 | $$SnakeskinParser.prototype.startTemplateLine;
|
| 591 |
|
| 592 | /** @type {string} */
|
| 593 | $$SnakeskinParser.prototype.bemRef;
|
| 594 |
|
| 595 | /** @type {!Array<boolean>} */
|
| 596 | $$SnakeskinParser.prototype.selfThis;
|
| 597 |
|
| 598 | /** @type {boolean} */
|
| 599 | $$SnakeskinParser.prototype.canWrite;
|
| 600 |
|
| 601 | /** @type {!Array<string>} */
|
| 602 | $$SnakeskinParser.prototype.decorators;
|
| 603 |
|
| 604 | /** @type {!Object} */
|
| 605 | $$SnakeskinParser.prototype.preDefs;
|
| 606 |
|
| 607 | /** @type {?string} */
|
| 608 | $$SnakeskinParser.prototype.outerLink;
|
| 609 |
|
| 610 | /** @type {boolean} */
|
| 611 | $$SnakeskinParser.prototype.space;
|
| 612 |
|
| 613 | /** @type {boolean} */
|
| 614 | $$SnakeskinParser.prototype.prevSpace;
|
| 615 |
|
| 616 | /** @type {!Array<boolean>} */
|
| 617 | $$SnakeskinParser.prototype.strongSpace;
|
| 618 |
|
| 619 | /** @type {boolean|number} */
|
| 620 | $$SnakeskinParser.prototype.sysSpace;
|
| 621 |
|
| 622 | /** @type {number} */
|
| 623 | $$SnakeskinParser.prototype.freezeLine;
|
| 624 |
|
| 625 | /** @type {number} */
|
| 626 | $$SnakeskinParser.prototype.i;
|
| 627 |
|
| 628 | /** @type {Object} */
|
| 629 | $$SnakeskinParser.prototype.blockStructure;
|
| 630 |
|
| 631 | /** @type {Object} */
|
| 632 | $$SnakeskinParser.prototype.blockTable;
|
| 633 |
|
| 634 | /**
|
| 635 | * @typedef {{
|
| 636 | * name: string,
|
| 637 | * parent: ?$$SnakeskinParserStructure,
|
| 638 | * params: !Object,
|
| 639 | * stack: !Array,
|
| 640 | * vars: Object,
|
| 641 | * children: Array,
|
| 642 | * logic: boolean,
|
| 643 | * chain: boolean
|
| 644 | * }}
|
| 645 | */
|
| 646 | var $$SnakeskinParserStructure;
|
| 647 |
|
| 648 | /** @type {?} */
|
| 649 | var name;
|
| 650 |
|
| 651 | /** @type {?} */
|
| 652 | var parent;
|
| 653 |
|
| 654 | /** @type {?} */
|
| 655 | var params;
|
| 656 |
|
| 657 | /** @type {?} */
|
| 658 | var stack;
|
| 659 |
|
| 660 | /** @type {?} */
|
| 661 | var children;
|
| 662 |
|
| 663 | /** @type {?} */
|
| 664 | var chain;
|
| 665 |
|
| 666 | /** @type {!Object} */
|
| 667 | $$SnakeskinParser.prototype.structure;
|
| 668 |
|
| 669 | /** @type {boolean} */
|
| 670 | $$SnakeskinParser.prototype.stringResult;
|
| 671 |
|
| 672 | /** @type {!Array} */
|
| 673 | $$SnakeskinParser.prototype.quotContent;
|
| 674 |
|
| 675 | /** @type {!Array} */
|
| 676 | $$SnakeskinParser.prototype.dirContent;
|
| 677 |
|
| 678 | /** @type {!Array} */
|
| 679 | $$SnakeskinParser.prototype.cdataContent;
|
| 680 |
|
| 681 | /** @type {!Object} */
|
| 682 | $$SnakeskinParser.prototype.files;
|
| 683 |
|
| 684 | /** @type {{exports, require, id, key, root, filename, parent, children, loaded, namespace}} */
|
| 685 | $$SnakeskinParser.prototype.environment;
|
| 686 |
|
| 687 | /** @type {string} */
|
| 688 | $$SnakeskinParser.prototype.source;
|
| 689 |
|
| 690 | /** @type {string} */
|
| 691 | $$SnakeskinParser.prototype.result;
|
| 692 |
|
| 693 | /**
|
| 694 | * @param {?string=} [opt_name]
|
| 695 | * @param {Object=} [opt_params]
|
| 696 | * @param {Object=} [opt_vars]
|
| 697 | * @return {!$$SnakeskinParser}
|
| 698 | */
|
| 699 | $$SnakeskinParser.prototype.startDir = function (opt_name, opt_params, opt_vars) {};
|
| 700 |
|
| 701 | /**
|
| 702 | * @param {?string=} [opt_name]
|
| 703 | * @param {Object=} [opt_params]
|
| 704 | * @return {!$$SnakeskinParser}
|
| 705 | */
|
| 706 | $$SnakeskinParser.prototype.startInlineDir = function (opt_name, opt_params) {};
|
| 707 |
|
| 708 | /**
|
| 709 | * @return {!$$SnakeskinParser}
|
| 710 | */
|
| 711 | $$SnakeskinParser.prototype.endDir = function () {};
|
| 712 |
|
| 713 | /**
|
| 714 | * @param {string} msg
|
| 715 | */
|
| 716 | $$SnakeskinParser.prototype.error = function (msg) {};
|
| 717 |
|
| 718 | /**
|
| 719 | * @param {string} str
|
| 720 | * @return {string}
|
| 721 | */
|
| 722 | $$SnakeskinParser.prototype.replaceDangerBlocks = function (str) {};
|
| 723 |
|
| 724 | /**
|
| 725 | * @param {string} str
|
| 726 | * @return {string}
|
| 727 | */
|
| 728 | $$SnakeskinParser.prototype.pasteDangerBlocks = function (str) {};
|
| 729 |
|
| 730 | /**
|
| 731 | * @param {string} str
|
| 732 | * @param {?boolean=} [opt_raw]
|
| 733 | * @return {?}
|
| 734 | */
|
| 735 | $$SnakeskinParser.prototype.evalStr = function (str, opt_raw) {};
|
| 736 |
|
| 737 | /**
|
| 738 | * @param {string} str
|
| 739 | * @return {?}
|
| 740 | */
|
| 741 | $$SnakeskinParser.prototype.returnEvalVal = function (str) {};
|
| 742 |
|
| 743 | /**
|
| 744 | * @param {...string} names
|
| 745 | * @return {!Object<string, boolean>}
|
| 746 | */
|
| 747 | $$SnakeskinParser.prototype.getGroup = function (names) {};
|
| 748 |
|
| 749 | /**
|
| 750 | * @param {...string} names
|
| 751 | * @return {!Array<string>}
|
| 752 | */
|
| 753 | $$SnakeskinParser.prototype.getGroupList = function (names) {};
|
| 754 |
|
| 755 | /**
|
| 756 | * @param {string} str
|
| 757 | * @param {(?function(string): string)=} [opt_fn]
|
| 758 | * @return {string}
|
| 759 | */
|
| 760 | $$SnakeskinParser.prototype.pasteTplVarBlocks = function (str, opt_fn) {};
|
| 761 |
|
| 762 | /** @typedef {{unsafe: (boolean|undefined), replace: (boolean|undefined)}} */
|
| 763 | var $$SnakeskinParserReplaceTplVarsParams;
|
| 764 |
|
| 765 | /** @type {?} */
|
| 766 | var unsafe;
|
| 767 |
|
| 768 | /** @type {?} */
|
| 769 | var replace;
|
| 770 |
|
| 771 | /**
|
| 772 | * @param {string} str
|
| 773 | * @param {?$$SnakeskinParserReplaceTplVarsParams=} [opt_params]
|
| 774 | * @param {(?function(string): string)=} [opt_wrap]
|
| 775 | * @return {string}
|
| 776 | */
|
| 777 | $$SnakeskinParser.prototype.replaceTplVars = function (str, opt_params, opt_wrap) {};
|
| 778 |
|
| 779 | /**
|
| 780 | * @param {string} str
|
| 781 | * @param {?boolean=} [opt_empty]
|
| 782 | * @return {string}
|
| 783 | */
|
| 784 | $$SnakeskinParser.prototype.getFnName = function (str, opt_empty) {};
|
| 785 |
|
| 786 | /**
|
| 787 | * @typedef {{
|
| 788 | * cache: (boolean|undefined),
|
| 789 | * unsafe: (boolean|undefined),
|
| 790 | * skipFirstWord: (boolean|undefined),
|
| 791 | * skipValidation: (boolean|undefined)
|
| 792 | * }}
|
| 793 | */
|
| 794 | var $$SnakeskinParserOutParams;
|
| 795 |
|
| 796 | /**
|
| 797 | * @param {string} command
|
| 798 | * @param {?$$SnakeskinParserOutParams=} [opt_params]
|
| 799 | * @return {string}
|
| 800 | */
|
| 801 | $$SnakeskinParser.prototype.out = function (command, opt_params) {};
|
| 802 |
|
| 803 | /**
|
| 804 | * @return {string}
|
| 805 | */
|
| 806 | $$SnakeskinParser.prototype.$ = function () {};
|
| 807 |
|
| 808 | /**
|
| 809 | * @return {string}
|
| 810 | */
|
| 811 | $$SnakeskinParser.prototype.$$ = function () {};
|
| 812 |
|
| 813 | /**
|
| 814 | * @param {?string=} [opt_str]
|
| 815 | * @return {string}
|
| 816 | */
|
| 817 | $$SnakeskinParser.prototype.wrap = function (opt_str) {};
|
| 818 |
|
| 819 | /**
|
| 820 | * @return {string}
|
| 821 | */
|
| 822 | $$SnakeskinParser.prototype.getResultDecl = function () {};
|
| 823 |
|
| 824 | /**
|
| 825 | * @return {string}
|
| 826 | */
|
| 827 | $$SnakeskinParser.prototype.getReturnResultDecl = function () {};
|
| 828 |
|
| 829 | /**
|
| 830 | * @return {boolean}
|
| 831 | */
|
| 832 | $$SnakeskinParser.prototype.isSimpleOutput = function () {};
|
| 833 |
|
| 834 | /**
|
| 835 | * @return {boolean}
|
| 836 | */
|
| 837 | $$SnakeskinParser.prototype.isAdvTest = function () {};
|
| 838 |
|
| 839 | /** @typedef {{iface: (boolean|undefined), raw: (boolean|undefined), jsDoc: (boolean|number|undefined)}} */
|
| 840 | var $$SnakeskinParserSaveParams;
|
| 841 |
|
| 842 | /** @type {?} */
|
| 843 | var iface;
|
| 844 |
|
| 845 | /** @type {?} */
|
| 846 | var raw;
|
| 847 |
|
| 848 | /** @type {?} */
|
| 849 | var jsDoc;
|
| 850 |
|
| 851 | /**
|
| 852 | * @param {string=} str
|
| 853 | * @param {?$$SnakeskinParserSaveParams=} [opt_params]
|
| 854 | * @return {(boolean|string)}
|
| 855 | */
|
| 856 | $$SnakeskinParser.prototype.save = function (str, opt_params) {};
|
| 857 |
|
| 858 | /**
|
| 859 | * @param {string=} str
|
| 860 | * @param {?$$SnakeskinParserSaveParams=} [opt_params]
|
| 861 | * @return {(boolean|string)}
|
| 862 | */
|
| 863 | $$SnakeskinParser.prototype.append = function (str, opt_params) {};
|
| 864 |
|
| 865 | /**
|
| 866 | * @param {string} tag
|
| 867 | * @param {?string=} [opt_attrs]
|
| 868 | * @param {?boolean=} [opt_inline]
|
| 869 | * @return {string}
|
| 870 | */
|
| 871 | $$SnakeskinParser.prototype.getXMLTagDecl = function (tag, opt_attrs, opt_inline) {};
|
| 872 |
|
| 873 | /**
|
| 874 | * @param {string} tag
|
| 875 | * @return {string}
|
| 876 | */
|
| 877 | $$SnakeskinParser.prototype.getXMLTagDeclStart = function (tag) {};
|
| 878 |
|
| 879 | /**
|
| 880 | * @param {?boolean=} [opt_inline]
|
| 881 | * @return {string}
|
| 882 | */
|
| 883 | $$SnakeskinParser.prototype.getXMLTagDeclEnd = function (opt_inline) {};
|
| 884 |
|
| 885 | /**
|
| 886 | * @param {?boolean=} [opt_inline]
|
| 887 | * @return {string}
|
| 888 | */
|
| 889 | $$SnakeskinParser.prototype.getEndXMLTagDecl = function (opt_inline) {};
|
| 890 |
|
| 891 | /**
|
| 892 | * @typedef {{
|
| 893 | * tag: string,
|
| 894 | * id: string,
|
| 895 | * classes: !Array<string>,
|
| 896 | * pseudo: !Array<string>,
|
| 897 | * inline: boolean,
|
| 898 | * inlineMap: (boolean|string)
|
| 899 | * }}
|
| 900 | */
|
| 901 | var $$SnakeskinParserGetXMLTagDescResult;
|
| 902 |
|
| 903 | /** @type {?} */
|
| 904 | var tag;
|
| 905 |
|
| 906 | /** @type {?} */
|
| 907 | var id;
|
| 908 |
|
| 909 | /** @type {?} */
|
| 910 | var classes;
|
| 911 |
|
| 912 | /** @type {?} */
|
| 913 | var pseudo;
|
| 914 |
|
| 915 | /** @type {?} */
|
| 916 | var inline;
|
| 917 |
|
| 918 | /** @type {?} */
|
| 919 | var inlineMap;
|
| 920 |
|
| 921 | /**
|
| 922 | * @param {string} str
|
| 923 | * @return {$$SnakeskinParserGetXMLTagDescResult}
|
| 924 | */
|
| 925 | $$SnakeskinParser.prototype.getXMLTagDesc = function (str) {};
|
| 926 |
|
| 927 | /**
|
| 928 | * @param {string} str
|
| 929 | * @return {!Array<string>}
|
| 930 | */
|
| 931 | $$SnakeskinParser.prototype.getTokens = function (str) {};
|
| 932 |
|
| 933 | /**
|
| 934 | * @return {?$$SnakeskinParserStructure}
|
| 935 | */
|
| 936 | $$SnakeskinParser.prototype.getNonLogicParent = function () {};
|
| 937 |
|
| 938 | /**
|
| 939 | * @return {boolean}
|
| 940 | */
|
| 941 | $$SnakeskinParser.prototype.isLogic = function () {};
|
| 942 |
|
| 943 | /**
|
| 944 | * @param {(string|!Object<string, boolean>|!Array<string>)} name
|
| 945 | * @param {?boolean=} [opt_return]
|
| 946 | * @return {(boolean|string|!Object)}
|
| 947 | */
|
| 948 | $$SnakeskinParser.prototype.has = function (name, opt_return) {};
|
| 949 |
|
| 950 | /**
|
| 951 | * @param {(string|!Object<string, boolean>|!Array<string>)} name
|
| 952 | * @param {?boolean=} [opt_return]
|
| 953 | * @return {(boolean|string|!Object)}
|
| 954 | */
|
| 955 | $$SnakeskinParser.prototype.hasParent = function (name, opt_return) {};
|
| 956 |
|
| 957 | /**
|
| 958 | * @param {(string|!Object<string, boolean>|!Array<string>)} name
|
| 959 | * @param {?boolean=} [opt_return]
|
| 960 | * @return {(boolean|string|!Object)}
|
| 961 | */
|
| 962 | $$SnakeskinParser.prototype.hasBlock = function (name, opt_return) {};
|
| 963 |
|
| 964 | /**
|
| 965 | * @param {(string|!Object<string, boolean>|!Array<string>)} name
|
| 966 | * @param {?boolean=} [opt_return]
|
| 967 | * @return {(boolean|string|!Object)}
|
| 968 | */
|
| 969 | $$SnakeskinParser.prototype.hasParentBlock = function (name, opt_return) {};
|
| 970 |
|
| 971 | /**
|
| 972 | * @return {($$SnakeskinParserStructure|boolean)}
|
| 973 | */
|
| 974 | $$SnakeskinParser.prototype.hasParentMicroTemplate = function () {};
|
| 975 |
|
| 976 | /**
|
| 977 | * @return {({asyncParent: (boolean|string), block: boolean, target: $$SnakeskinParserStructure}|boolean)}
|
| 978 | */
|
| 979 | $$SnakeskinParser.prototype.hasParentFunction = function () {};
|
| 980 |
|
| 981 | /** @typedef {{end: (boolean|undefined), def: (string|undefined), sys: (boolean|undefined)}} */
|
| 982 | var $$SnakeskinParserDeclVarsParams;
|
| 983 |
|
| 984 | /** @typedef {{fn: (boolean|undefined), sys: (boolean|undefined)}} */
|
| 985 | var $$SnakeskinParserDeclVarParams;
|
| 986 |
|
| 987 | /** @type {?} */
|
| 988 | var end;
|
| 989 |
|
| 990 | /** @type {?} */
|
| 991 | var def;
|
| 992 |
|
| 993 | /** @type {?} */
|
| 994 | var sys;
|
| 995 |
|
| 996 | /** @type {?} */
|
| 997 | var fn;
|
| 998 |
|
| 999 | /**
|
| 1000 | * @param {string} name
|
| 1001 | * @return {string}
|
| 1002 | */
|
| 1003 | $$SnakeskinParser.prototype.getVar = function (name) {};
|
| 1004 |
|
| 1005 | /**
|
| 1006 | * @param {string} name
|
| 1007 | * @param {?$$SnakeskinParserDeclVarParams=} [opt_params]
|
| 1008 | * @return {string}
|
| 1009 | */
|
| 1010 | $$SnakeskinParser.prototype.declVar = function (name, opt_params) {};
|
| 1011 |
|
| 1012 | /**
|
| 1013 | * @param {string} str
|
| 1014 | * @param {?$$SnakeskinParserDeclVarsParams=} [opt_params]
|
| 1015 | * @return {string}
|
| 1016 | */
|
| 1017 | $$SnakeskinParser.prototype.declVars = function (str, opt_params) {};
|