Lines Matching +defs:data +defs:value
422 var isFunction = function isFunction(value) {
423 return typeof value === 'function';
428 exports.isFunction = isFunction = function (value) {
429 return typeof value === 'function' && toString.call(value) === '[object Function]';
437 var isArray = Array.isArray || function (value) {
438 return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
444 function indexOf(array, value) {
446 if (array[i] === value) {
476 function isEmpty(value) {
477 if (!value && value !== 0) {
479 } else if (isArray(value) && value.length === 0) {
545 // Work around issue under safari where we can't directly set the column value
549 value: column,
553 value: endColumn,
693 if (options.data && options.ids) {
694 var data = _utils.createFrame(options.data);
695 data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
696 options = { data: data };
740 data = undefined,
743 if (options.data && options.ids) {
744 contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
751 if (options.data) {
752 data = _utils.createFrame(options.data);
756 if (data) {
757 data.key = field;
758 data.index = index;
759 data.first = index === 0;
760 data.last = !!last;
763 data.contextPath = contextPath + field;
768 data: data,
784 newContext.push(it.value);
877 get: function(){ return setDesc(this, 'a', {value: 7}).a; }
891 set: function(value){
893 setSymbolDesc(this, tag, createDesc(1, value));
961 if($replacer || !isArray(replacer))replacer = function(key, value){
962 if($replacer)value = $replacer.call(this, key, value);
963 if(!isSymbol(value))return value;
1057 // 24.3.2 JSON.stringify(value [, replacer [, space]])
1210 module.exports = __webpack_require__(18) ? function(object, key, value){
1211 return $.setDesc(object, key, createDesc(1, value));
1212 } : function(object, key, value){
1213 object[key] = value;
1221 module.exports = function(bitmap, value){
1226 value : value
1250 if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
1445 if(index >= O.length)return {value: undefined, done: true};
1448 return {value: point, done: false};
1636 module.exports = function(done, value){
1637 return {value: value, done: !!done};
1804 // Default behavior is to render the positive path if the value is truthy and not empty.
1847 } else if (options.data && options.data.level != null) {
1848 level = options.data.level;
1906 var data = options.data;
1907 if (options.data && options.ids) {
1908 data = _utils.createFrame(options.data);
1909 data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
1913 data: data,
1914 blockParams: _utils.blockParams([context], [data && data.contextPath])
1990 // Maps a given level value to the `methodMap` indexes above.
2328 program: function program(i, data, declaredBlockParams, blockParams, depths) {
2331 if (data || depths || blockParams || declaredBlockParams) {
2332 programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
2339 data: function data(value, depth) {
2340 while (value && depth--) {
2341 value = value._parent;
2343 return value;
2364 var data = options.data;
2368 data = initData(context, data);
2381 return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
2384 main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
2419 ret._child = function (i, data, blockParams, depths) {
2427 return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
2432 function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
2441 return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
2444 prog = executeDecorators(fn, prog, container, depths, data, blockParams);
2459 partial = options.data['partial-block'];
2473 var currentPartialBlock = options.data && options.data['partial-block'];
2476 options.data.contextPath = options.ids[0] || options.data.contextPath;
2482 options.data = _base.createFrame(options.data);
2485 partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) {
2490 options.data = _base.createFrame(options.data);
2491 options.data['partial-block'] = currentPartialBlock;
2515 function initData(context, data) {
2516 if (!data || !('root' in data)) {
2517 data = data ? _base.createFrame(data) : {};
2518 data.root = context;
2520 return data;
2523 function executeDecorators(fn, prog, container, depths, data, blockParams) {
2526 prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
2768 value: yy.stripComment($$[$0]),
2778 value: $$[$0],
2865 this.$ = { type: 'HashPair', key: yy.id($$[$0 - 2]), value: $$[$0], loc: yy.locInfo(this._$) };
2877 this.$ = { type: 'StringLiteral', value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$) };
2880 this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
2883 this.$ = { type: 'BooleanLiteral', value: $$[$0] === 'true', original: $$[$0] === 'true', loc: yy.locInfo(this._$) };
2886 this.$ = { type: 'UndefinedLiteral', original: undefined, value: undefined, loc: yy.locInfo(this._$) };
2889 this.$ = { type: 'NullLiteral', original: null, value: null, loc: yy.locInfo(this._$) };
3659 var original = current.value;
3660 current.value = current.value.replace(multiple ? /^\s+/ : /^[ \t]*\r?\n?/, '');
3661 current.rightStripped = current.value !== original;
3678 var original = current.value;
3679 current.value = current.value.replace(multiple ? /\s+$/ : /[ \t]+$/, '');
3680 current.leftStripped = current.value !== original;
3709 // Visits a given value. If mutating, will replace the value if necessary.
3711 var value = this.accept(node[name]);
3715 if (value && !Visitor.prototype[value.type]) {
3716 throw new _exception2['default']('Unexpected node type "' + value.type + '" found when accepting ' + name + ' on ' + node.type);
3718 node[name] = value;
3806 this.acceptRequired(pair, 'value');
3895 function preparePath(data, parts, loc) {
3898 var original = data ? '@' : '',
3923 data: data,
4095 // and then proceed as if the resulting value was provided to blockHelperMissing.
4294 if (content.value) {
4295 this.opcode('appendContent', content.value);
4367 } else if (path.data) {
4368 this.options.data = true;
4376 this.opcode('pushString', string.value);
4380 this.opcode('pushLiteral', number.value);
4384 this.opcode('pushLiteral', bool.value);
4403 this.pushParam(pairs[i].value);
4470 var value = val.value != null ? val.value : val.original || '';
4473 if (value.replace) {
4474 value = value.replace(/^(\.?\.\/)*/g, '').replace(/\//g, '.');
4481 this.opcode('pushStringParam', value, val.type);
4498 value = val.original || value;
4499 if (value.replace) {
4500 value = value.replace(/^this(?:\.|$)/, '').replace(/^\.\//, '').replace(/^\.$/, '');
4503 this.opcode('pushId', val.type, value);
4543 if (!('data' in options)) {
4544 options.data = true;
4563 if (!('data' in options)) {
4564 options.data = true;
4592 ret._child = function (i, data, blockParams, depths) {
4596 return compiled._child(i, data, blockParams, depths);
4623 data: false,
4656 function Literal(value) {
4657 this.value = value;
4770 this.decorators = Function.apply(this, ['fn', 'props', 'container', 'depth0', 'data', 'blockParams', 'depths', this.decorators.merge()]);
4772 this.decorators.prepend('function(fn, props, container, depth0, data, blockParams, depths) {\n');
4809 if (this.options.data) {
4883 var params = ['container', 'depth0', 'helpers', 'partials', 'data'];
4967 // On stack, before: hash, inverse, program, value
4968 // On stack, after: return value of blockHelperMissing
4971 // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and
4987 // On stack, before: hash, inverse, program, value
4988 // Compiler value, before: lastHelper=value of last found helper, if any
4990 // On stack, after, if lastHelper: value
4992 // We're being a bit cheeky and reusing the options value from the prior exec
5010 // Appends the string value of `content` to the current buffer
5023 // On stack, before: value, ...
5026 // Coerces `value` to a String and appends it to the current buffer.
5028 // If `value` is truthy, or 0, it is coerced into a string and appended
5048 // On stack, before: value, ...
5051 // Escape `value` and append it to the buffer
5060 // Compiler value, after: lastContext=depth
5062 // Set the value of the `lastContext` compiler value to the depth
5072 // Pushes the value of the current context onto the stack.
5082 // Looks up the value of `name` on the current context and pushes
5103 // Looks up the value of `parts` on the given block param and pushes
5115 // On stack, after: data, ...
5117 // Push the data lookup operator
5120 this.pushStackLiteral('data');
5122 this.pushStackLiteral('container.data(data, ' + depth + ')');
5125 this.resolvePath('data', parts, 0, true, strict);
5158 // On stack, before: value, ...
5159 // On stack, after: resolved value, ...
5161 // If the `value` is a lambda, replace it on the stack by
5162 // the return value of the lambda
5173 // provides the string value of a parameter along with its
5234 // On stack, after: value, ...
5236 // Pushes a value onto the stack. This operation prevents
5239 pushLiteral: function pushLiteral(value) {
5240 this.pushStackLiteral(value);
5279 // and pushes the helper's return value onto the stack.
5394 // On stack, before: value, ..., hash, ...
5397 // Pops a value off the stack and assigns it to the current hash
5399 var value = this.popStack(),
5422 hash.values[key] = value;
5485 programParams = [child.index, 'data', child.blockParams];
5544 stack = [top.value];
5601 return item.value;
5620 return item.value;
5731 if (this.options.data) {
5732 options.data = 'data';
5931 var value = castChunk(obj[key], _this);
5932 if (value !== 'undefined') {
5933 pairs.push([_this.quotedString(key), ':', value]);