Lines Matching defs:options
119 hb.compile = function (input, options) {
120 return _handlebarsCompilerCompiler.compile(input, options, hb);
122 hb.precompile = function (input, options) {
123 return _handlebarsCompilerCompiler.precompile(input, options, hb);
674 instance.registerHelper('blockHelperMissing', function (context, options) {
675 var inverse = options.inverse,
676 fn = options.fn;
684 if (options.ids) {
685 options.ids = [options.name];
688 return instance.helpers.each(context, options);
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 };
699 return fn(context, options);
731 instance.registerHelper('each', function (context, options) {
732 if (!options) {
736 var fn = options.fn,
737 inverse = options.inverse,
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);
1766 instance.registerHelper('helperMissing', function () /* [args, ]options */{
1796 instance.registerHelper('if', function (conditional, options) {
1807 if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {
1808 return options.inverse(this);
1810 return options.fn(this);
1814 instance.registerHelper('unless', function (conditional, options) {
1819 fn: options.inverse,
1820 inverse: options.fn,
1821 hash: options.hash
1837 instance.registerHelper('log', function () /* message, options */{
1839 options = arguments[arguments.length - 1];
1845 if (options.hash.level != null) {
1846 level = options.hash.level;
1847 } else if (options.data && options.data.level != null) {
1848 level = options.data.level;
1867 instance.registerHelper('lookup', function (obj, field, options) {
1872 return options.lookupProperty(obj, field);
1895 instance.registerHelper('with', function (context, options) {
1903 var fn = options.fn;
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]);
1917 return options.inverse(this);
1954 instance.registerDecorator('inline', function (fn, props, container, options) {
1958 ret = function (context, options) {
1962 var ret = fn(context, options);
1968 props.partials[options.args[0]] = options.fn;
2097 _logger2['default'].log('error', 'Handlebars: Access has been denied to resolve the property "' + propertyName + '" because it is not an "own property" of its parent.\n' + 'You can add a runtime option to disable the check or this warning:\n' + 'See https://handlebarsjs.com/api-reference/runtime-options.html#options-to-control-prototype-access for details');
2243 function invokePartialWrapper(partial, context, options) {
2244 if (options.hash) {
2245 context = Utils.extend({}, context, options.hash);
2246 if (options.ids) {
2247 options.ids[0] = true;
2250 partial = env.VM.resolvePartial.call(this, partial, context, options);
2252 var extendedOptions = Utils.extend({}, options, {
2260 options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
2261 result = options.partials[options.name](context, extendedOptions);
2264 if (options.indent) {
2271 lines[i] = options.indent + lines[i];
2277 throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
2362 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
2364 var data = options.data;
2366 ret._setup(options);
2367 if (!options.partial && templateSpec.useData) {
2373 if (options.depths) {
2374 depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;
2380 function main(context /*, options*/) {
2384 main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
2385 return main(context, options);
2390 ret._setup = function (options) {
2391 if (!options.partial) {
2392 var mergedHelpers = Utils.extend({}, env.helpers, options.helpers);
2398 container.partials = container.mergeIfNeeded(options.partials, env.partials);
2401 container.decorators = Utils.extend({}, env.decorators, options.decorators);
2405 container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options);
2407 var keepHelperInHelpers = options.allowCallsToHelperMissing || templateWasPrecompiledWithCompilerV7;
2411 container.protoAccessControl = options.protoAccessControl; // internal option
2412 container.helpers = options.helpers;
2413 container.partials = options.partials;
2414 container.decorators = options.decorators;
2415 container.hooks = options.hooks;
2434 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
2441 return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
2456 function resolvePartial(partial, context, options) {
2458 if (options.name === '@partial-block') {
2459 partial = options.data['partial-block'];
2461 partial = options.partials[options.name];
2463 } else if (!partial.call && !options.name) {
2465 options.name = partial;
2466 partial = options.partials[partial];
2471 function invokePartial(partial, context, options) {
2473 var currentPartialBlock = options.data && options.data['partial-block'];
2474 options.partial = true;
2475 if (options.ids) {
2476 options.data.contextPath = options.ids[0] || options.data.contextPath;
2480 if (options.fn && options.fn !== noop) {
2482 options.data = _base.createFrame(options.data);
2484 var fn = options.fn;
2485 partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) {
2486 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
2490 options.data = _base.createFrame(options.data);
2491 options.data['partial-block'] = currentPartialBlock;
2492 return fn(context, options);
2495 options.partials = Utils.extend({}, options.partials, fn.partials);
2505 throw new _exception2['default']('The partial ' + options.name + ' could not be found');
2507 return partial(context, options);
2541 return _internalWrapHelper.wrapHelper(helper, function (options) {
2542 return Utils.extend({ lookupProperty: lookupProperty }, options);
2588 var options = arguments[arguments.length - 1];
2589 arguments[arguments.length - 1] = transformOptionsFn(options);
2697 function parseWithoutProcessing(input, options) {
2707 return new yy.SourceLocation(options && options.srcName, locInfo);
2715 function parse(input, options) {
2716 var ast = parseWithoutProcessing(input, options);
2717 var strip = new _whitespaceControl2['default'](options);
3013 var ranges = this.lexer.options && this.lexer.options.ranges;
3131 if (this.options.ranges) this.yylloc.range = [0, 0];
3149 if (this.options.ranges) this.yylloc.range[1]++;
3175 if (this.options.ranges) {
3220 if (!this.options.flex) break;
3234 if (this.options.ranges) {
3273 lexer.options = {};
3478 var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
3480 this.options = options;
3485 var doStandalone = !this.options.ignoreStandalone;
3588 if (!this.options.ignoreStandalone && isPrevWhitespace(program.body) && isNextWhitespace(firstInverse.body)) {
4128 compile: function compile(program, options) {
4132 this.options = options;
4133 this.stringParams = options.stringParams;
4134 this.trackIds = options.trackIds;
4136 options.blockParams = options.blockParams || [];
4138 options.knownHelpers = _utils.extend(_Object$create(null), {
4147 }, options.knownHelpers);
4155 result = childCompiler.compile(program, this.options),
4179 this.options.blockParams.unshift(program.blockParams);
4187 this.options.blockParams.shift();
4252 if (this.options.explicitPartialContext) {
4268 if (this.options.preventIndent && indent) {
4283 if (mustache.escaped && !this.options.noEscape) {
4341 if (this.options.knownHelpers[name]) {
4343 } else if (this.options.knownHelpersOnly) {
4368 this.options.data = true;
4446 options = this.options;
4447 if (options.knownHelpers[_name]) {
4449 } else if (options.knownHelpersOnly) {
4527 for (var depth = 0, len = this.options.blockParams.length; depth < len; depth++) {
4528 var blockParams = this.options.blockParams[depth],
4537 function precompile(input, options, env) {
4542 options = options || {};
4543 if (!('data' in options)) {
4544 options.data = true;
4546 if (options.compat) {
4547 options.useDepths = true;
4550 var ast = env.parse(input, options),
4551 environment = new env.Compiler().compile(ast, options);
4552 return new env.JavaScriptCompiler().compile(environment, options);
4555 function compile(input, options, env) {
4556 if (options === undefined) options = {};
4562 options = _utils.extend({}, options);
4563 if (!('data' in options)) {
4564 options.data = true;
4566 if (options.compat) {
4567 options.useDepths = true;
4573 var ast = env.parse(input, options),
4574 environment = new env.Compiler().compile(ast, options),
4575 templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true);
4709 compile: function compile(environment, options, context, asObject) {
4711 this.options = options;
4712 this.stringParams = this.options.stringParams;
4713 this.trackIds = this.options.trackIds;
4735 this.compileChildren(environment, options);
4737 this.useDepths = this.useDepths || environment.useDepths || environment.useDecorators || this.options.compat;
4809 if (this.options.data) {
4818 if (this.options.compat) {
4828 if (options.srcName) {
4829 ret = ret.toStringWithSourceMap({ file: options.destName });
4835 ret.compilerOptions = this.options;
4848 this.source = new _codeGen2['default'](this.options.srcName);
4849 this.decorators = new _codeGen2['default'](this.options.srcName);
4992 // We're being a bit cheeky and reusing the options value from the prior exec
5087 if (!scoped && this.options.compat && !this.lastContext) {
5133 if (this.options.strict || this.options.assumeObjects) {
5134 this.push(strictLookup(this.options.strict && strict, this, parts, i, type));
5268 options = this.setupHelperArgs(name, paramSize);
5270 this.decorators.push(['fn = ', this.decorators.functionCall(foundDecorator, '', ['fn', 'props', 'container', options]), ' || fn;']);
5294 if (!this.options.strict) {
5332 // This operation emits more code than the other options,
5346 if (!this.options.strict) {
5363 options = this.setupParams(name, 1, params);
5367 delete options.name;
5371 options.indent = JSON.stringify(indent);
5373 options.helpers = 'helpers';
5374 options.partials = 'partials';
5375 options.decorators = 'container.decorators';
5383 if (this.options.compat) {
5384 options.depths = 'depths';
5386 options = this.objectLiteral(options);
5387 params.push(options);
5441 compileChildren: function compileChildren(environment, options) {
5457 this.context.programs[index] = compiler.compile(child, options, this.context, !this.precompile);
5671 var options = {},
5682 options.name = this.quotedString(helper);
5683 options.hash = this.popStack();
5686 options.hashIds = this.popStack();
5689 options.hashTypes = this.popStack();
5690 options.hashContexts = this.popStack();
5697 // helpers to do a check for `if (options.fn)`
5699 options.fn = program || 'container.noop';
5700 options.inverse = inverse || 'container.noop';
5720 options.args = this.source.generateArray(params);
5724 options.ids = this.source.generateArray(ids);
5727 options.types = this.source.generateArray(types);
5728 options.contexts = this.source.generateArray(contexts);
5731 if (this.options.data) {
5732 options.data = 'data';
5735 options.blockParams = 'blockParams';
5737 return options;
5741 var options = this.setupParams(helper, paramSize, params);
5742 options.loc = JSON.stringify(this.source.currentLocation);
5743 options = this.objectLiteral(options);
5745 this.useRegister('options');
5746 params.push('options');
5747 return ['options=', options];
5749 params.push(options);
5752 return options;