`);
- }
- emitter.write(`| `);
- yield r.renderTemplates(this.templates, ctx, emitter);
- emitter.write(' | ');
- }
- if (collection.length)
- emitter.write('
');
- ctx.pop();
- }
-}
-
-class UnlessTag extends Tag {
- constructor(tagToken, remainTokens, liquid, parser) {
- super(tagToken, remainTokens, liquid);
- this.branches = [];
- this.elseTemplates = [];
- let p = [];
- let elseCount = 0;
- parser.parseStream(remainTokens)
- .on('start', () => this.branches.push({
- value: new Value(tagToken.args, this.liquid),
- test: isFalsy,
- templates: (p = [])
- }))
- .on('tag:elsif', (token) => {
- if (elseCount > 0) {
- p = [];
- return;
- }
- this.branches.push({
- value: new Value(token.args, this.liquid),
- test: isTruthy,
- templates: (p = [])
- });
- })
- .on('tag:else', () => {
- elseCount++;
- p = this.elseTemplates;
- })
- .on('tag:endunless', function () { this.stop(); })
- .on('template', (tpl) => {
- if (p !== this.elseTemplates || elseCount === 1) {
- p.push(tpl);
- }
- })
- .on('end', () => { throw new Error(`tag ${tagToken.getText()} not closed`); })
- .start();
- }
- *render(ctx, emitter) {
- const r = this.liquid.renderer;
- for (const { value, test, templates } of this.branches) {
- const v = yield value.value(ctx, ctx.opts.lenientIf);
- if (test(v, ctx)) {
- yield r.renderTemplates(templates, ctx, emitter);
- return;
- }
- }
- yield r.renderTemplates(this.elseTemplates, ctx, emitter);
- }
-}
-
-class BreakTag extends Tag {
- render(ctx, emitter) {
- emitter['break'] = true;
- }
-}
-
-class ContinueTag extends Tag {
- render(ctx, emitter) {
- emitter['continue'] = true;
- }
-}
-
-class EchoTag extends Tag {
- constructor(token, remainTokens, liquid) {
- super(token, remainTokens, liquid);
- this.tokenizer.skipBlank();
- if (!this.tokenizer.end()) {
- this.value = new Value(this.tokenizer.readFilteredValue(), this.liquid);
- }
- }
- *render(ctx, emitter) {
- if (!this.value)
- return;
- const val = yield this.value.value(ctx, false);
- emitter.write(val);
- }
-}
-
-class LiquidTag extends Tag {
- constructor(token, remainTokens, liquid, parser) {
- super(token, remainTokens, liquid);
- const tokens = this.tokenizer.readLiquidTagTokens(this.liquid.options);
- this.templates = parser.parseTokens(tokens);
- }
- *render(ctx, emitter) {
- yield this.liquid.renderer.renderTemplates(this.templates, ctx, emitter);
- }
-}
-
-class InlineCommentTag extends Tag {
- constructor(tagToken, remainTokens, liquid) {
- super(tagToken, remainTokens, liquid);
- if (tagToken.args.search(/\n\s*[^#\s]/g) !== -1) {
- throw new Error('every line of an inline comment must start with a \'#\' character');
- }
- }
- render() { }
-}
-
-const tags = {
- assign: AssignTag,
- 'for': ForTag,
- capture: CaptureTag,
- 'case': CaseTag,
- comment: CommentTag,
- include: IncludeTag,
- render: RenderTag,
- decrement: DecrementTag,
- increment: IncrementTag,
- cycle: CycleTag,
- 'if': IfTag,
- layout: LayoutTag,
- block: BlockTag,
- raw: RawTag,
- tablerow: TablerowTag,
- unless: UnlessTag,
- 'break': BreakTag,
- 'continue': ContinueTag,
- echo: EchoTag,
- liquid: LiquidTag,
- '#': InlineCommentTag
+class AssignTag extends Tag {
+ constructor(token, remainTokens, liquid) {
+ super(token, remainTokens, liquid);
+ this.key = this.tokenizer.readIdentifier().content;
+ this.tokenizer.assert(this.key, 'expected variable name');
+ this.tokenizer.skipBlank();
+ this.tokenizer.assert(this.tokenizer.peek() === '=', 'expected "="');
+ this.tokenizer.advance();
+ this.value = new Value(this.tokenizer.readFilteredValue(), this.liquid);
+ }
+ *render(ctx) {
+ ctx.bottom()[this.key] = yield this.value.value(ctx, this.liquid.options.lenientIf);
+ }
+}
+
+const MODIFIERS = ['offset', 'limit', 'reversed'];
+class ForTag extends Tag {
+ constructor(token, remainTokens, liquid, parser) {
+ super(token, remainTokens, liquid);
+ const variable = this.tokenizer.readIdentifier();
+ const inStr = this.tokenizer.readIdentifier();
+ const collection = this.tokenizer.readValue();
+ if (!variable.size() || inStr.content !== 'in' || !collection) {
+ throw new Error(`illegal tag: ${token.getText()}`);
+ }
+ this.variable = variable.content;
+ this.collection = collection;
+ this.hash = new Hash(this.tokenizer.remaining(), liquid.options.keyValueSeparator);
+ this.templates = [];
+ this.elseTemplates = [];
+ let p;
+ const stream = parser.parseStream(remainTokens)
+ .on('start', () => (p = this.templates))
+ .on('tag:else', tag => { assertEmpty(tag.args); p = this.elseTemplates; })
+ .on('tag:endfor', tag => { assertEmpty(tag.args); stream.stop(); })
+ .on('template', (tpl) => p.push(tpl))
+ .on('end', () => { throw new Error(`tag ${token.getText()} not closed`); });
+ stream.start();
+ }
+ *render(ctx, emitter) {
+ const r = this.liquid.renderer;
+ let collection = toEnumerable(yield evalToken(this.collection, ctx));
+ if (!collection.length) {
+ yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+ return;
+ }
+ const continueKey = 'continue-' + this.variable + '-' + this.collection.getText();
+ ctx.push({ continue: ctx.getRegister(continueKey) });
+ const hash = yield this.hash.render(ctx);
+ ctx.pop();
+ const modifiers = this.liquid.options.orderedFilterParameters
+ ? Object.keys(hash).filter(x => MODIFIERS.includes(x))
+ : MODIFIERS.filter(x => hash[x] !== undefined);
+ collection = modifiers.reduce((collection, modifier) => {
+ if (modifier === 'offset')
+ return offset(collection, hash['offset']);
+ if (modifier === 'limit')
+ return limit(collection, hash['limit']);
+ return reversed(collection);
+ }, collection);
+ ctx.setRegister(continueKey, (hash['offset'] || 0) + collection.length);
+ const scope = { forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) };
+ ctx.push(scope);
+ for (const item of collection) {
+ scope[this.variable] = item;
+ yield r.renderTemplates(this.templates, ctx, emitter);
+ if (emitter['break']) {
+ emitter['break'] = false;
+ break;
+ }
+ emitter['continue'] = false;
+ scope.forloop.next();
+ }
+ ctx.pop();
+ }
+}
+function reversed(arr) {
+ return [...arr].reverse();
+}
+function offset(arr, count) {
+ return arr.slice(count);
+}
+function limit(arr, count) {
+ return arr.slice(0, count);
+}
+
+class CaptureTag extends Tag {
+ constructor(tagToken, remainTokens, liquid, parser) {
+ super(tagToken, remainTokens, liquid);
+ this.templates = [];
+ this.variable = this.readVariableName();
+ while (remainTokens.length) {
+ const token = remainTokens.shift();
+ if (isTagToken(token) && token.name === 'endcapture')
+ return;
+ this.templates.push(parser.parseToken(token, remainTokens));
+ }
+ throw new Error(`tag ${tagToken.getText()} not closed`);
+ }
+ *render(ctx) {
+ const r = this.liquid.renderer;
+ const html = yield r.renderTemplates(this.templates, ctx);
+ ctx.bottom()[this.variable] = html;
+ }
+ readVariableName() {
+ const word = this.tokenizer.readIdentifier().content;
+ if (word)
+ return word;
+ const quoted = this.tokenizer.readQuoted();
+ if (quoted)
+ return evalQuotedToken(quoted);
+ throw this.tokenizer.error('invalid capture name');
+ }
+}
+
+class CaseTag extends Tag {
+ constructor(tagToken, remainTokens, liquid, parser) {
+ super(tagToken, remainTokens, liquid);
+ this.branches = [];
+ this.elseTemplates = [];
+ this.value = new Value(this.tokenizer.readFilteredValue(), this.liquid);
+ this.elseTemplates = [];
+ let p = [];
+ let elseCount = 0;
+ const stream = parser.parseStream(remainTokens)
+ .on('tag:when', (token) => {
+ if (elseCount > 0) {
+ return;
+ }
+ p = [];
+ const values = [];
+ while (!token.tokenizer.end()) {
+ values.push(token.tokenizer.readValueOrThrow());
+ token.tokenizer.skipBlank();
+ if (token.tokenizer.peek() === ',') {
+ token.tokenizer.readTo(',');
+ }
+ else {
+ token.tokenizer.readTo('or');
+ }
+ }
+ this.branches.push({
+ values,
+ templates: p
+ });
+ })
+ .on('tag:else', () => {
+ elseCount++;
+ p = this.elseTemplates;
+ })
+ .on('tag:endcase', () => stream.stop())
+ .on('template', (tpl) => {
+ if (p !== this.elseTemplates || elseCount === 1) {
+ p.push(tpl);
+ }
+ })
+ .on('end', () => {
+ throw new Error(`tag ${tagToken.getText()} not closed`);
+ });
+ stream.start();
+ }
+ *render(ctx, emitter) {
+ const r = this.liquid.renderer;
+ const target = toValue(yield this.value.value(ctx, ctx.opts.lenientIf));
+ let branchHit = false;
+ for (const branch of this.branches) {
+ for (const valueToken of branch.values) {
+ const value = yield evalToken(valueToken, ctx, ctx.opts.lenientIf);
+ if (equals(target, value)) {
+ yield r.renderTemplates(branch.templates, ctx, emitter);
+ branchHit = true;
+ break;
+ }
+ }
+ }
+ if (!branchHit) {
+ yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+ }
+ }
+}
+
+class CommentTag extends Tag {
+ constructor(tagToken, remainTokens, liquid) {
+ super(tagToken, remainTokens, liquid);
+ while (remainTokens.length) {
+ const token = remainTokens.shift();
+ if (isTagToken(token) && token.name === 'endcomment')
+ return;
+ }
+ throw new Error(`tag ${tagToken.getText()} not closed`);
+ }
+ render() { }
+}
+
+class RenderTag extends Tag {
+ constructor(token, remainTokens, liquid, parser) {
+ super(token, remainTokens, liquid);
+ const tokenizer = this.tokenizer;
+ this.file = parseFilePath(tokenizer, this.liquid, parser);
+ this.currentFile = token.file;
+ while (!tokenizer.end()) {
+ tokenizer.skipBlank();
+ const begin = tokenizer.p;
+ const keyword = tokenizer.readIdentifier();
+ if (keyword.content === 'with' || keyword.content === 'for') {
+ tokenizer.skipBlank();
+ // can be normal key/value pair, like "with: true"
+ if (tokenizer.peek() !== ':') {
+ const value = tokenizer.readValue();
+ // can be normal key, like "with,"
+ if (value) {
+ const beforeAs = tokenizer.p;
+ const asStr = tokenizer.readIdentifier();
+ let alias;
+ if (asStr.content === 'as')
+ alias = tokenizer.readIdentifier();
+ else
+ tokenizer.p = beforeAs;
+ this[keyword.content] = { value, alias: alias && alias.content };
+ tokenizer.skipBlank();
+ if (tokenizer.peek() === ',')
+ tokenizer.advance();
+ continue; // matched!
+ }
+ }
+ }
+ /**
+ * restore cursor if with/for not matched
+ */
+ tokenizer.p = begin;
+ break;
+ }
+ this.hash = new Hash(tokenizer.remaining(), liquid.options.keyValueSeparator);
+ }
+ *render(ctx, emitter) {
+ const { liquid, hash } = this;
+ const filepath = (yield renderFilePath(this['file'], ctx, liquid));
+ assert(filepath, () => `illegal file path "${filepath}"`);
+ const childCtx = ctx.spawn();
+ const scope = childCtx.bottom();
+ __assign(scope, yield hash.render(ctx));
+ if (this['with']) {
+ const { value, alias } = this['with'];
+ scope[alias || filepath] = yield evalToken(value, ctx);
+ }
+ if (this['for']) {
+ const { value, alias } = this['for'];
+ const collection = toEnumerable(yield evalToken(value, ctx));
+ scope['forloop'] = new ForloopDrop(collection.length, value.getText(), alias);
+ for (const item of collection) {
+ scope[alias] = item;
+ const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile']));
+ yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
+ scope['forloop'].next();
+ }
+ }
+ else {
+ const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile']));
+ yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
+ }
+ }
+}
+/**
+ * @return null for "none",
+ * @return Template[] for quoted with tags and/or filters
+ * @return Token for expression (not quoted)
+ * @throws TypeError if cannot read next token
+ */
+function parseFilePath(tokenizer, liquid, parser) {
+ if (liquid.options.dynamicPartials) {
+ const file = tokenizer.readValue();
+ tokenizer.assert(file, 'illegal file path');
+ if (file.getText() === 'none')
+ return;
+ if (isQuotedToken(file)) {
+ // for filenames like "files/{{file}}", eval as liquid template
+ const templates = parser.parse(evalQuotedToken(file));
+ return optimize(templates);
+ }
+ return file;
+ }
+ const tokens = [...tokenizer.readFileNameTemplate(liquid.options)];
+ const templates = optimize(parser.parseTokens(tokens));
+ return templates === 'none' ? undefined : templates;
+}
+function optimize(templates) {
+ // for filenames like "files/file.liquid", extract the string directly
+ if (templates.length === 1 && isHTMLToken(templates[0].token))
+ return templates[0].token.getContent();
+ return templates;
+}
+function* renderFilePath(file, ctx, liquid) {
+ if (typeof file === 'string')
+ return file;
+ if (Array.isArray(file))
+ return liquid.renderer.renderTemplates(file, ctx);
+ return yield evalToken(file, ctx);
+}
+
+class IncludeTag extends Tag {
+ constructor(token, remainTokens, liquid, parser) {
+ super(token, remainTokens, liquid);
+ const { tokenizer } = token;
+ this['file'] = parseFilePath(tokenizer, this.liquid, parser);
+ this['currentFile'] = token.file;
+ const begin = tokenizer.p;
+ const withStr = tokenizer.readIdentifier();
+ if (withStr.content === 'with') {
+ tokenizer.skipBlank();
+ if (tokenizer.peek() !== ':') {
+ this.withVar = tokenizer.readValue();
+ }
+ else
+ tokenizer.p = begin;
+ }
+ else
+ tokenizer.p = begin;
+ this.hash = new Hash(tokenizer.remaining(), liquid.options.jekyllInclude || liquid.options.keyValueSeparator);
+ }
+ *render(ctx, emitter) {
+ const { liquid, hash, withVar } = this;
+ const { renderer } = liquid;
+ const filepath = (yield renderFilePath(this['file'], ctx, liquid));
+ assert(filepath, () => `illegal file path "${filepath}"`);
+ const saved = ctx.saveRegister('blocks', 'blockMode');
+ ctx.setRegister('blocks', {});
+ ctx.setRegister('blockMode', BlockMode.OUTPUT);
+ const scope = (yield hash.render(ctx));
+ if (withVar)
+ scope[filepath] = yield evalToken(withVar, ctx);
+ const templates = (yield liquid._parsePartialFile(filepath, ctx.sync, this['currentFile']));
+ ctx.push(ctx.opts.jekyllInclude ? { include: scope } : scope);
+ yield renderer.renderTemplates(templates, ctx, emitter);
+ ctx.pop();
+ ctx.restoreRegister(saved);
+ }
+}
+
+class DecrementTag extends Tag {
+ constructor(token, remainTokens, liquid) {
+ super(token, remainTokens, liquid);
+ this.variable = this.tokenizer.readIdentifier().content;
+ }
+ render(context, emitter) {
+ const scope = context.environments;
+ if (!isNumber(scope[this.variable])) {
+ scope[this.variable] = 0;
+ }
+ emitter.write(stringify(--scope[this.variable]));
+ }
+}
+
+class CycleTag extends Tag {
+ constructor(token, remainTokens, liquid) {
+ super(token, remainTokens, liquid);
+ this.candidates = [];
+ const group = this.tokenizer.readValue();
+ this.tokenizer.skipBlank();
+ if (group) {
+ if (this.tokenizer.peek() === ':') {
+ this.group = group;
+ this.tokenizer.advance();
+ }
+ else
+ this.candidates.push(group);
+ }
+ while (!this.tokenizer.end()) {
+ const value = this.tokenizer.readValue();
+ if (value)
+ this.candidates.push(value);
+ this.tokenizer.readTo(',');
+ }
+ this.tokenizer.assert(this.candidates.length, () => `empty candidates: "${token.getText()}"`);
+ }
+ *render(ctx, emitter) {
+ const group = (yield evalToken(this.group, ctx));
+ const fingerprint = `cycle:${group}:` + this.candidates.join(',');
+ const groups = ctx.getRegister('cycle');
+ let idx = groups[fingerprint];
+ if (idx === undefined) {
+ idx = groups[fingerprint] = 0;
+ }
+ const candidate = this.candidates[idx];
+ idx = (idx + 1) % this.candidates.length;
+ groups[fingerprint] = idx;
+ return yield evalToken(candidate, ctx);
+ }
+}
+
+class IfTag extends Tag {
+ constructor(tagToken, remainTokens, liquid, parser) {
+ super(tagToken, remainTokens, liquid);
+ this.branches = [];
+ let p = [];
+ parser.parseStream(remainTokens)
+ .on('start', () => this.branches.push({
+ value: new Value(tagToken.args, this.liquid),
+ templates: (p = [])
+ }))
+ .on('tag:elsif', (token) => {
+ assert(!this.elseTemplates, 'unexpected elsif after else');
+ this.branches.push({
+ value: new Value(token.args, this.liquid),
+ templates: (p = [])
+ });
+ })
+ .on('tag:else', tag => {
+ assertEmpty(tag.args);
+ assert(!this.elseTemplates, 'duplicated else');
+ p = this.elseTemplates = [];
+ })
+ .on('tag:endif', function (tag) { assertEmpty(tag.args); this.stop(); })
+ .on('template', (tpl) => p.push(tpl))
+ .on('end', () => { throw new Error(`tag ${tagToken.getText()} not closed`); })
+ .start();
+ }
+ *render(ctx, emitter) {
+ const r = this.liquid.renderer;
+ for (const { value, templates } of this.branches) {
+ const v = yield value.value(ctx, ctx.opts.lenientIf);
+ if (isTruthy(v, ctx)) {
+ yield r.renderTemplates(templates, ctx, emitter);
+ return;
+ }
+ }
+ yield r.renderTemplates(this.elseTemplates || [], ctx, emitter);
+ }
+}
+
+class IncrementTag extends Tag {
+ constructor(token, remainTokens, liquid) {
+ super(token, remainTokens, liquid);
+ this.variable = this.tokenizer.readIdentifier().content;
+ }
+ render(context, emitter) {
+ const scope = context.environments;
+ if (!isNumber(scope[this.variable])) {
+ scope[this.variable] = 0;
+ }
+ const val = scope[this.variable];
+ scope[this.variable]++;
+ emitter.write(stringify(val));
+ }
+}
+
+class LayoutTag extends Tag {
+ constructor(token, remainTokens, liquid, parser) {
+ super(token, remainTokens, liquid);
+ this.file = parseFilePath(this.tokenizer, this.liquid, parser);
+ this['currentFile'] = token.file;
+ this.args = new Hash(this.tokenizer.remaining(), liquid.options.keyValueSeparator);
+ this.templates = parser.parseTokens(remainTokens);
+ }
+ *render(ctx, emitter) {
+ const { liquid, args, file } = this;
+ const { renderer } = liquid;
+ if (file === undefined) {
+ ctx.setRegister('blockMode', BlockMode.OUTPUT);
+ yield renderer.renderTemplates(this.templates, ctx, emitter);
+ return;
+ }
+ const filepath = (yield renderFilePath(this.file, ctx, liquid));
+ assert(filepath, () => `illegal file path "${filepath}"`);
+ const templates = (yield liquid._parseLayoutFile(filepath, ctx.sync, this['currentFile']));
+ // render remaining contents and store rendered results
+ ctx.setRegister('blockMode', BlockMode.STORE);
+ const html = yield renderer.renderTemplates(this.templates, ctx);
+ const blocks = ctx.getRegister('blocks');
+ // set whole content to anonymous block if anonymous doesn't specified
+ if (blocks[''] === undefined)
+ blocks[''] = (parent, emitter) => emitter.write(html);
+ ctx.setRegister('blockMode', BlockMode.OUTPUT);
+ // render the layout file use stored blocks
+ ctx.push((yield args.render(ctx)));
+ yield renderer.renderTemplates(templates, ctx, emitter);
+ ctx.pop();
+ }
+}
+
+class BlockTag extends Tag {
+ constructor(token, remainTokens, liquid, parser) {
+ super(token, remainTokens, liquid);
+ this.templates = [];
+ const match = /\w+/.exec(token.args);
+ this.block = match ? match[0] : '';
+ while (remainTokens.length) {
+ const token = remainTokens.shift();
+ if (isTagToken(token) && token.name === 'endblock')
+ return;
+ const template = parser.parseToken(token, remainTokens);
+ this.templates.push(template);
+ }
+ throw new Error(`tag ${token.getText()} not closed`);
+ }
+ *render(ctx, emitter) {
+ const blockRender = this.getBlockRender(ctx);
+ if (ctx.getRegister('blockMode') === BlockMode.STORE) {
+ ctx.getRegister('blocks')[this.block] = blockRender;
+ }
+ else {
+ yield blockRender(new BlockDrop(), emitter);
+ }
+ }
+ getBlockRender(ctx) {
+ const { liquid, templates } = this;
+ const renderChild = ctx.getRegister('blocks')[this.block];
+ const renderCurrent = function* (superBlock, emitter) {
+ // add {{ block.super }} support when rendering
+ ctx.push({ block: superBlock });
+ yield liquid.renderer.renderTemplates(templates, ctx, emitter);
+ ctx.pop();
+ };
+ return renderChild
+ ? (superBlock, emitter) => renderChild(new BlockDrop(() => renderCurrent(superBlock, emitter)), emitter)
+ : renderCurrent;
+ }
+}
+
+class RawTag extends Tag {
+ constructor(tagToken, remainTokens, liquid) {
+ super(tagToken, remainTokens, liquid);
+ this.tokens = [];
+ while (remainTokens.length) {
+ const token = remainTokens.shift();
+ if (isTagToken(token) && token.name === 'endraw')
+ return;
+ this.tokens.push(token);
+ }
+ throw new Error(`tag ${tagToken.getText()} not closed`);
+ }
+ render() {
+ return this.tokens.map((token) => token.getText()).join('');
+ }
+}
+
+class TablerowloopDrop extends ForloopDrop {
+ constructor(length, cols, collection, variable) {
+ super(length, collection, variable);
+ this.length = length;
+ this.cols = cols;
+ }
+ row() {
+ return Math.floor(this.i / this.cols) + 1;
+ }
+ col0() {
+ return (this.i % this.cols);
+ }
+ col() {
+ return this.col0() + 1;
+ }
+ col_first() {
+ return this.col0() === 0;
+ }
+ col_last() {
+ return this.col() === this.cols;
+ }
+}
+
+class TablerowTag extends Tag {
+ constructor(tagToken, remainTokens, liquid, parser) {
+ super(tagToken, remainTokens, liquid);
+ const variable = this.tokenizer.readIdentifier();
+ this.tokenizer.skipBlank();
+ const predicate = this.tokenizer.readIdentifier();
+ const collectionToken = this.tokenizer.readValue();
+ if (predicate.content !== 'in' || !collectionToken) {
+ throw new Error(`illegal tag: ${tagToken.getText()}`);
+ }
+ this.variable = variable.content;
+ this.collection = collectionToken;
+ this.args = new Hash(this.tokenizer.remaining(), liquid.options.keyValueSeparator);
+ this.templates = [];
+ let p;
+ const stream = parser.parseStream(remainTokens)
+ .on('start', () => (p = this.templates))
+ .on('tag:endtablerow', () => stream.stop())
+ .on('template', (tpl) => p.push(tpl))
+ .on('end', () => {
+ throw new Error(`tag ${tagToken.getText()} not closed`);
+ });
+ stream.start();
+ }
+ *render(ctx, emitter) {
+ let collection = toEnumerable(yield evalToken(this.collection, ctx));
+ const args = (yield this.args.render(ctx));
+ const offset = args.offset || 0;
+ const limit = (args.limit === undefined) ? collection.length : args.limit;
+ collection = collection.slice(offset, offset + limit);
+ const cols = args.cols || collection.length;
+ const r = this.liquid.renderer;
+ const tablerowloop = new TablerowloopDrop(collection.length, cols, this.collection.getText(), this.variable);
+ const scope = { tablerowloop };
+ ctx.push(scope);
+ for (let idx = 0; idx < collection.length; idx++, tablerowloop.next()) {
+ scope[this.variable] = collection[idx];
+ if (tablerowloop.col0() === 0) {
+ if (tablerowloop.row() !== 1)
+ emitter.write('');
+ emitter.write(`