Unexpected '--', expecting end of attribute in n:class (in '.../taxonomies/blog.latte' on line 55 at column 23) search►

410:        }
411:    
412:    
413:        /**
414:         * Throws if the tag parser has not consumed all tokens.
415:         */
416:        public function ensureIsConsumed(Tag $tag): void
417:        {
418:            if (!$tag->parser->isEnd()) {
419:                $end = $tag->isNAttribute() ? ['end of attribute'] : ['end of tag'];
420:                $tag->parser->stream->throwUnexpectedException($end, addendum: ' in ' . $tag->getNotation());
421:            }
422:        }
423:    
424:    

' in n:class'

570:        {
571:            $toClose = [];
572:            foreach ($toOpen as $tag) {
573:                $parser = $this->getAttrParser($tag->name, $tag->position);
574:                $this->parser->pushTag($tag);
575:                $res = $parser($tag, $this->parser);
576:                if ($res instanceof \Generator && $res->valid()) {
577:                    $toClose[] = [$res, $tag];
578:    
579:                } elseif ($res instanceof AreaNode) {
580:                    $this->parser->ensureIsConsumed($tag);
581:                    $res->position = $tag->position;
582:                    $res->end ??= $tag->end;
583:                    $tag->replaceNAttribute($res);
584:                    $this->parser->popTag();

111:        private function parseElement(): Node
112:        {
113:            $res = new FragmentNode;
114:            $res->append($this->extractIndentation());
115:            $res->append($this->parseStartTag($this->element));
116:            $elem = $this->element;
117:    
118:            $stream = $this->parser->getStream();
119:            $void = $this->resolveVoidness($elem);
120:            $attrs = $this->prepareNAttrs($elem->nAttributes, $void);
121:            $outerNodes = $this->openNAttrNodes($attrs[Tag::PrefixNone] ?? []);
122:            $tagNodes = $this->openNAttrNodes($attrs[Tag::PrefixTag] ?? []);
123:            if ($tagNodes) {
124:                $elem->dynamicTag = $this->finishNAttrNodes($elem->dynamicTag ?? new Nodes\Html\TagNode($elem), $tagNodes);
125:            }

77:    
78:    
79:        private function parseTag(): ?Node
80:        {
81:            $stream = $this->parser->getStream();
82:            $lexer = $this->parser->getLexer();
83:            $lexer->pushState(TemplateLexer::StateHtmlTag);
84:            $closing = $stream->tryPeek(1)?->is(Token::Slash);
85:            $lexer->popState();
86:            if (!$closing) {
87:                return $this->parseElement();
88:            }
89:    
90:            if ($this->element
91:                && $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element

45:        {
46:            return $this->element;
47:        }
48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };

 98:         * @param  \Closure(FragmentNode): ?Node  $resolver
 99:         * @param  ?(\Closure(FragmentNode): void)  $after
100:         */
101:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
102:        {
103:            $res = new FragmentNode;
104:            $save = [$this->lastResolver, $this->tag];
105:            $this->lastResolver = $resolver;
106:            try {
107:                while (!$this->stream->peek()->isEnd()) {
108:                    if ($node = $resolver($res)) {
109:                        assert($node instanceof Nodes\AreaNode);
110:                        $res->append($node);
111:                        $after && $after($res);
112:                    } else {

128:                if ($elem->isRawText()) {
129:                    $this->parser->getLexer()->pushState(TemplateLexer::StateHtmlRawText, $elem->name);
130:                }
131:                $content = new FragmentNode;
132:                if ($token = $stream->tryConsume(Token::Newline)) {
133:                    $content->append(new Nodes\TextNode($token->text, $token->position, $token->end));
134:                }
135:    
136:                $innerNodes = $this->openNAttrNodes($attrs[Tag::PrefixInner] ?? []);
137:                $this->elementData[$elem]->tag = $this->parser->peekTag();
138:                $frag = $this->parser->parseFragment($this->inTextResolve(...));
139:                $content->append($this->finishNAttrNodes($frag, $innerNodes));
140:                if ($elem->isRawText()) {
141:                    $this->parser->getLexer()->popState();
142:                }

77:    
78:    
79:        private function parseTag(): ?Node
80:        {
81:            $stream = $this->parser->getStream();
82:            $lexer = $this->parser->getLexer();
83:            $lexer->pushState(TemplateLexer::StateHtmlTag);
84:            $closing = $stream->tryPeek(1)?->is(Token::Slash);
85:            $lexer->popState();
86:            if (!$closing) {
87:                return $this->parseElement();
88:            }
89:    
90:            if ($this->element
91:                && $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element

45:        {
46:            return $this->element;
47:        }
48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };

 98:         * @param  \Closure(FragmentNode): ?Node  $resolver
 99:         * @param  ?(\Closure(FragmentNode): void)  $after
100:         */
101:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
102:        {
103:            $res = new FragmentNode;
104:            $save = [$this->lastResolver, $this->tag];
105:            $this->lastResolver = $resolver;
106:            try {
107:                while (!$this->stream->peek()->isEnd()) {
108:                    if ($node = $resolver($res)) {
109:                        assert($node instanceof Nodes\AreaNode);
110:                        $res->append($node);
111:                        $after && $after($res);
112:                    } else {

128:                if ($elem->isRawText()) {
129:                    $this->parser->getLexer()->pushState(TemplateLexer::StateHtmlRawText, $elem->name);
130:                }
131:                $content = new FragmentNode;
132:                if ($token = $stream->tryConsume(Token::Newline)) {
133:                    $content->append(new Nodes\TextNode($token->text, $token->position, $token->end));
134:                }
135:    
136:                $innerNodes = $this->openNAttrNodes($attrs[Tag::PrefixInner] ?? []);
137:                $this->elementData[$elem]->tag = $this->parser->peekTag();
138:                $frag = $this->parser->parseFragment($this->inTextResolve(...));
139:                $content->append($this->finishNAttrNodes($frag, $innerNodes));
140:                if ($elem->isRawText()) {
141:                    $this->parser->getLexer()->popState();
142:                }

77:    
78:    
79:        private function parseTag(): ?Node
80:        {
81:            $stream = $this->parser->getStream();
82:            $lexer = $this->parser->getLexer();
83:            $lexer->pushState(TemplateLexer::StateHtmlTag);
84:            $closing = $stream->tryPeek(1)?->is(Token::Slash);
85:            $lexer->popState();
86:            if (!$closing) {
87:                return $this->parseElement();
88:            }
89:    
90:            if ($this->element
91:                && $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element

45:        {
46:            return $this->element;
47:        }
48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };

 98:         * @param  \Closure(FragmentNode): ?Node  $resolver
 99:         * @param  ?(\Closure(FragmentNode): void)  $after
100:         */
101:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
102:        {
103:            $res = new FragmentNode;
104:            $save = [$this->lastResolver, $this->tag];
105:            $this->lastResolver = $resolver;
106:            try {
107:                while (!$this->stream->peek()->isEnd()) {
108:                    if ($node = $resolver($res)) {
109:                        assert($node instanceof Nodes\AreaNode);
110:                        $res->append($node);
111:                        $after && $after($res);
112:                    } else {

212:                $this->ensureIsConsumed($startTag);
213:                if ($startTag->outputMode === $startTag::OutputKeepIndentation) {
214:                    $this->lastIndentation = null;
215:                }
216:    
217:                if ($startTag->void) {
218:                    $res->send([new FragmentNode, $startTag]);
219:                } else {
220:                    while ($res->valid()) {
221:                        $this->lookFor[$startTag] = $res->current() ?: null;
222:                        $content = $this->parseFragment($resolver ?? $this->lastResolver);
223:                        if ($this->dedent) {
224:                            Dedent::apply($content, $startTag);
225:                        }
226:    

124:        /**
125:         * Resolves the next node in plain text context (text, indentation, Latte tag, or comment).
126:         */
127:        public function inTextResolve(): ?Node
128:        {
129:            $token = $this->stream->peek();
130:            return match ($token->type) {
131:                Token::Text => $this->parseText(),
132:                Token::Indentation => $this->parseIndentation(),
133:                Token::Newline => $this->parseNewline(),
134:                Token::Latte_TagOpen => $this->parseLatteStatement(),
135:                Token::Latte_CommentOpen => $this->parseLatteComment(),
136:                default => null,
137:            };
138:        }

48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };
60:        }
61:    
62:    

 98:         * @param  \Closure(FragmentNode): ?Node  $resolver
 99:         * @param  ?(\Closure(FragmentNode): void)  $after
100:         */
101:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
102:        {
103:            $res = new FragmentNode;
104:            $save = [$this->lastResolver, $this->tag];
105:            $this->lastResolver = $resolver;
106:            try {
107:                while (!$this->stream->peek()->isEnd()) {
108:                    if ($node = $resolver($res)) {
109:                        assert($node instanceof Nodes\AreaNode);
110:                        $res->append($node);
111:                        $after && $after($res);
112:                    } else {

69:            $this->lookFor = new \WeakMap;
70:    
71:            $headLength = 0;
72:            $findLength = function (FragmentNode $fragment) use (&$headLength) {
73:                if ($this->inHead && !end($fragment->children) instanceof Nodes\TextNode) {
74:                    $headLength = count($fragment->children);
75:                }
76:            };
77:    
78:            $node = new Nodes\TemplateNode;
79:            $node->main = $this->parseFragment($this->html->inTextResolve(...), $findLength);
80:            $node->head = new FragmentNode(array_splice($node->main->children, 0, $headLength));
81:            $node->contentType = $this->contentType;
82:    
83:            if (!$this->stream->peek()->isEnd()) {

161:            $parser->dedent = $this->hasFeature(Feature::Dedent);
162:    
163:            foreach ($this->extensions as $extension) {
164:                $extension->beforeCompile($this);
165:                $parser->addTags($extension->getTags());
166:            }
167:    
168:            return $parser
169:                ->setContentType($this->contentType)
170:                ->setPolicy($this->getPolicy(effective: true))
171:                ->parse($template);
172:        }
173:    
174:    
175:        /**

123:         */
124:        public function compile(string $name): string
125:        {
126:            if ($this->sandboxed && !$this->policy) {
127:                throw new \LogicException('In sandboxed mode you need to set a security policy.');
128:            }
129:    
130:            $template = $this->getLoader()->getContent($name);
131:    
132:            try {
133:                $node = $this->parse($template);
134:                $this->applyPasses($node);
135:                $compiled = $this->generate($node, $name);
136:    
137:            } catch (\Throwable $e) {

217:    
218:        /** @return class-string<Runtime\Template> */
219:        private function loadTemplate(string $name): string
220:        {
221:            $class = $this->getTemplateClass($name);
222:            if (class_exists($class, autoload: false)) {
223:                // nothing
224:            } elseif ($this->cache->directory) {
225:                $this->cache->loadOrCreate($this, $name);
226:            } else {
227:                $compiled = $this->compile($name);
228:                try {
229:                    eval(substr($compiled, 5)); // substr removes <?php
230:                } catch (\ParseError $e) {
231:                    throw (new CompileException('Error in template: ' . $e->getMessage(), previous: $e))

'/www/hosting/ssi.cz/www/wp-content/themes/ssi/Templates/taxonomies/blog.latte'

 99:        }
100:    
101:    
102:        /**
103:         * Creates template object.
104:         * @param  mixed[]  $params
105:         */
106:        public function createTemplate(string $name, array $params = [], bool $clearCache = true): Runtime\Template
107:        {
108:            $this->configurationHash = $clearCache ? null : $this->configurationHash;
109:            $class = $this->loadTemplate($name);
110:            $this->providers->fn = $this->functions;
111:            return new $class(
112:                $this,
113:                $params,

'/www/hosting/ssi.cz/www/wp-content/themes/ssi/Templates/taxonomies/blog.latte'

 86:            $template->render($block);
 87:        }
 88:    
 89:    
 90:        /**
 91:         * Renders template to string.
 92:         * @param  object|mixed[]  $params
 93:         */
 94:        public function renderToString(string $name, object|array $params = [], ?string $block = null): string
 95:        {
 96:            $template = $this->createTemplate($name, Helpers::resolveParams($this, $params));
 97:            $template->global->coreCaptured = true;
 98:            return $template->capture(fn() => $template->render($block));
 99:        }
100:    

'/www/hosting/ssi.cz/www/wp-content/themes/ssi/Templates/taxonomies/blog.latte'

293:       * Render template
294:       *
295:         * @param string $template
296:         * @param bool $cache
297:       *
298:       * @author Leximo <hi@leximo.cz>
299:       * @version 1.0.0
300:       */
301:    
302:       public function render($template, $cache = false) {
303:            echo $this->renderToString($template, $cache);
304:        }
305:    
306:      /**
307:       * View template (for main rendering)

'/www/hosting/ssi.cz/www/wp-content/themes/ssi/Templates/taxonomies/blog.latte'

false

19:    // Add tags
20:    $presenter['tags'] = Leximo::getMenu('tags');
21:    
22:    // Add pagination
23:    $presenter['pagination'] = Leximo::getPagination();
24:    
25:    // Add terms
26:    $presenter['terms'] = Leximo::getTerms(['taxonomy' => 'category']);
27:    
28:    // Render
29:    $presenter->render('taxonomies/blog');

'taxonomies/blog'

122:        ) {
123:            /**
124:             * Fires immediately before including the template.
125:             *
126:             * @since 6.9.0
127:             *
128:             * @param string $template The path of the template about to be included.
129:             */
130:            do_action( 'wp_before_include_template', $template );
131:    
132:            include $template;
133:        } elseif ( current_user_can( 'switch_themes' ) ) {
134:            $theme = wp_get_theme();
135:            if ( $theme->errors() ) {
136:                wp_die( $theme->errors() );

'/www/hosting/ssi.cz/www/wp-content/themes/ssi/category.php'

 9:    
10:        $wp_did_header = true;
11:    
12:        // Load the WordPress library.
13:        require_once __DIR__ . '/wp-load.php';
14:    
15:        // Set up the WordPress query.
16:        wp();
17:    
18:        // Load the theme template.
19:        require_once ABSPATH . WPINC . '/template-loader.php';
20:    
21:    }

'/www/hosting/ssi.cz/www/wp-includes/template-loader.php'

 7:     */
 8:    
 9:    /**
10:     * Tells WordPress to load the WordPress theme and output it.
11:     *
12:     * @var bool
13:     */
14:    define( 'WP_USE_THEMES', true );
15:    
16:    /** Loads the WordPress Environment and Template */
17:    require __DIR__ . '/wp-blog-header.php';

'/www/hosting/ssi.cz/www/wp-blog-header.php'