binja 0.7.2 → 0.8.0

package/README.md

@@ -27,10 +27,11 @@
 |---------|-----------|------------------|
 | **Runtime Performance** | ✅ 2-4x faster | ❌ |
 | **AOT Compilation** | ✅ 160x faster | ❌ |
+| **Multi-Engine** | ✅ Jinja2, Handlebars, Liquid | ❌ |
 | Django DTL Compatible | ✅ 100% | ❌ Partial |
 | Jinja2 Compatible | ✅ Full | ⚠️ Limited |
 | Template Inheritance | ✅ | ⚠️ |
-| 80+ Built-in Filters | ✅ | ❌ |
+| 84 Built-in Filters | ✅ | ❌ |
 | 28 Built-in Tests | ✅ | ❌ |
 | Debug Panel | ✅ | ❌ |
 | CLI Tool | ✅ | ⚠️ |
@@ -418,6 +419,69 @@ console.log(Object.keys(builtinTests))
 
 ---
 
+## Multi-Engine Support
+
+Binja supports multiple template engines through a unified API. All engines parse to a common AST and share the same runtime, filters, and optimizations.
+
+### Supported Engines
+
+| Engine | Syntax | Use Case |
+|--------|--------|----------|
+| **Jinja2/DTL** | `{{ var }}` `{% if %}` | Default, Python/Django compatibility |
+| **Handlebars** | `{{var}}` `{{#if}}` | JavaScript ecosystem, Ember.js |
+| **Liquid** | `{{ var }}` `{% if %}` | Shopify, Jekyll, static sites |
+
+### Usage
+
+```typescript
+// Direct engine imports
+import * as handlebars from 'binja/engines/handlebars'
+import * as liquid from 'binja/engines/liquid'
+
+// Handlebars
+await handlebars.render('Hello {{name}}!', { name: 'World' })
+await handlebars.render('{{#each items}}{{this}}{{/each}}', { items: ['a', 'b'] })
+await handlebars.render('{{{html}}}', { html: '<b>unescaped</b>' })
+
+// Liquid (Shopify)
+await liquid.render('Hello {{ name }}!', { name: 'World' })
+await liquid.render('{% for item in items %}{{ item }}{% endfor %}', { items: ['a', 'b'] })
+await liquid.render('{% assign x = "value" %}{{ x }}', {})
+```
+
+### MultiEngine API
+
+```typescript
+import { MultiEngine } from 'binja/engines'
+
+const engine = new MultiEngine()
+
+// Render with any engine
+await engine.render('Hello {{name}}!', { name: 'World' }, 'handlebars')
+await engine.render('Hello {{ name }}!', { name: 'World' }, 'liquid')
+await engine.render('Hello {{ name }}!', { name: 'World' }, 'jinja2')
+
+// Auto-detect from file extension
+import { detectEngine } from 'binja/engines'
+const eng = detectEngine('template.hbs')  // Returns Handlebars engine
+const eng2 = detectEngine('page.liquid')  // Returns Liquid engine
+```
+
+### Engine Feature Matrix
+
+| Feature | Jinja2 | Handlebars | Liquid |
+|---------|--------|------------|--------|
+| Variables | `{{ x }}` | `{{x}}` | `{{ x }}` |
+| Conditionals | `{% if %}` | `{{#if}}` | `{% if %}` |
+| Loops | `{% for %}` | `{{#each}}` | `{% for %}` |
+| Filters | `{{ x\|filter }}` | `{{ x }}` | `{{ x \| filter }}` |
+| Raw output | `{% raw %}` | - | `{% raw %}` |
+| Comments | `{# #}` | `{{! }}` | `{% comment %}` |
+| Assignment | `{% set %}` | - | `{% assign %}` |
+| Unescaped | `{{ x\|safe }}` | `{{{x}}}` | - |
+
+---
+
 ## Django Compatibility
 
 binja is designed to be a drop-in replacement for Django templates:

package/dist/engines/handlebars/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Handlebars Engine
+ * Converts Handlebars templates to binja's common AST format
+ */
+import type { TemplateNode } from '../../parser/nodes';
+export { HandlebarsLexer, HbsTokenType, type HbsToken } from './lexer';
+export { HandlebarsParser } from './parser';
+/**
+ * Parse a Handlebars template string into an AST
+ */
+export declare function parse(source: string): TemplateNode;
+/**
+ * Compile a Handlebars template to a render function
+ */
+export declare function compile(source: string): (context: Record<string, any>) => Promise<string>;
+/**
+ * Render a Handlebars template with context
+ */
+export declare function render(source: string, context?: Record<string, any>): Promise<string>;
+/**
+ * Engine interface for multi-engine support
+ */
+export declare const engine: {
+    name: string;
+    extensions: string[];
+    parse: typeof parse;
+    compile: typeof compile;
+    render: typeof render;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/engines/handlebars/lexer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Handlebars Lexer
+ * Tokenizes Handlebars template syntax: {{expr}}, {{#if}}, {{/if}}, {{>partial}}
+ */
+export declare enum HbsTokenType {
+    TEXT = "TEXT",
+    OPEN = "OPEN",// {{
+    OPEN_BLOCK = "OPEN_BLOCK",// {{#
+    OPEN_END = "OPEN_END",// {{/
+    OPEN_PARTIAL = "OPEN_PARTIAL",// {{>
+    OPEN_UNESCAPED = "OPEN_UNESCAPED",// {{{
+    OPEN_COMMENT = "OPEN_COMMENT",// {{!
+    CLOSE = "CLOSE",// }}
+    CLOSE_UNESCAPED = "CLOSE_UNESCAPED",// }}}
+    ID = "ID",// identifier
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    DOT = "DOT",
+    DOTDOT = "DOTDOT",// ..
+    SLASH = "SLASH",
+    EQUALS = "EQUALS",
+    PIPE = "PIPE",
+    EOF = "EOF"
+}
+export interface HbsToken {
+    type: HbsTokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+export declare class HandlebarsLexer {
+    private source;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    constructor(source: string);
+    tokenize(): HbsToken[];
+    private scanToken;
+    private scanText;
+    private scanExpression;
+    private scanExpressionToken;
+    private scanString;
+    private scanNumber;
+    private scanIdentifier;
+    private scanComment;
+    private scanBlockComment;
+    private isAtEnd;
+    private peek;
+    private peekNext;
+    private advance;
+    private check;
+    private match;
+    private skipWhitespace;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private addToken;
+}
+//# sourceMappingURL=lexer.d.ts.map

package/dist/engines/handlebars/parser.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Handlebars Parser
+ * Converts Handlebars tokens to a common AST format
+ */
+import { HbsToken } from './lexer';
+import type { TemplateNode } from '../../parser/nodes';
+export declare class HandlebarsParser {
+    private tokens;
+    private current;
+    private source;
+    constructor(tokens: HbsToken[], source?: string);
+    parse(): TemplateNode;
+    private parseNodes;
+    private parseNode;
+    private parseText;
+    private parseOutput;
+    private parseBlock;
+    private parseIfBlock;
+    private parseUnlessBlock;
+    private parseEachBlock;
+    private parseWithBlock;
+    private parseCustomBlock;
+    private parsePartial;
+    private parseExpression;
+    private parseExpressionAtom;
+    private parsePath;
+    private checkOpenBlock;
+    private consumeElse;
+    private consumeEndBlock;
+    private skipComment;
+    private isAtEnd;
+    private peek;
+    private advance;
+    private check;
+    private expect;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/engines/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Multi-Engine Support
+ * Unified interface for multiple template engines
+ */
+import * as handlebars from './handlebars';
+import * as liquid from './liquid';
+export { handlebars, liquid };
+/**
+ * Engine interface
+ */
+export interface TemplateEngine {
+    name: string;
+    extensions: string[];
+    parse: (source: string) => any;
+    compile: (source: string) => (context: Record<string, any>) => Promise<string>;
+    render: (source: string, context?: Record<string, any>) => Promise<string>;
+}
+/**
+ * Registry of all available engines
+ */
+export declare const engines: Record<string, TemplateEngine>;
+/**
+ * Get engine by name or file extension
+ */
+export declare function getEngine(nameOrExt: string): TemplateEngine | undefined;
+/**
+ * Detect engine from file path
+ */
+export declare function detectEngine(filePath: string): TemplateEngine | undefined;
+/**
+ * Render a template with auto-detected engine
+ */
+export declare function render(source: string, context?: Record<string, any>, engineName?: string): Promise<string>;
+/**
+ * Multi-engine environment for API service
+ */
+export declare class MultiEngine {
+    private defaultEngine;
+    constructor(defaultEngine?: string);
+    /**
+     * Render with specified engine
+     */
+    render(source: string, context?: Record<string, any>, engineName?: string): Promise<string>;
+    /**
+     * Compile template with specified engine
+     */
+    compile(source: string, engineName?: string): (context: Record<string, any>) => Promise<string>;
+    /**
+     * List all available engines
+     */
+    listEngines(): string[];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/engines/liquid/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Liquid Engine
+ * Converts Liquid (Shopify) templates to binja's common AST format
+ */
+import type { TemplateNode } from '../../parser/nodes';
+export { LiquidLexer, LiquidTokenType, type LiquidToken } from './lexer';
+export { LiquidParser } from './parser';
+/**
+ * Parse a Liquid template string into an AST
+ */
+export declare function parse(source: string): TemplateNode;
+/**
+ * Compile a Liquid template to a render function
+ */
+export declare function compile(source: string): (context: Record<string, any>) => Promise<string>;
+/**
+ * Render a Liquid template with context
+ */
+export declare function render(source: string, context?: Record<string, any>): Promise<string>;
+/**
+ * Engine interface for multi-engine support
+ */
+export declare const engine: {
+    name: string;
+    extensions: string[];
+    parse: typeof parse;
+    compile: typeof compile;
+    render: typeof render;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/engines/liquid/lexer.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Liquid Lexer
+ * Tokenizes Liquid template syntax: {{ output }}, {% tags %}
+ * Shopify-compatible implementation
+ */
+export declare enum LiquidTokenType {
+    TEXT = "TEXT",
+    VAR_START = "VAR_START",// {{
+    VAR_END = "VAR_END",// }}
+    TAG_START = "TAG_START",// {%
+    TAG_END = "TAG_END",// %}
+    ID = "ID",
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    DOT = "DOT",
+    PIPE = "PIPE",
+    COLON = "COLON",
+    COMMA = "COMMA",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    RANGE = "RANGE",// ..
+    EQUALS = "EQUALS",// =
+    EQ = "EQ",// ==
+    NE = "NE",// != or <>
+    LT = "LT",
+    LE = "LE",
+    GT = "GT",
+    GE = "GE",
+    CONTAINS = "CONTAINS",
+    AND = "AND",
+    OR = "OR",
+    EOF = "EOF"
+}
+export interface LiquidToken {
+    type: LiquidTokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+export declare class LiquidLexer {
+    private source;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    constructor(source: string);
+    tokenize(): LiquidToken[];
+    private scanToken;
+    private checkRawTag;
+    private scanRawBlock;
+    private scanText;
+    private scanExpression;
+    private scanExpressionToken;
+    private scanString;
+    private scanNumber;
+    private scanIdentifier;
+    private isAtEnd;
+    private peek;
+    private peekNext;
+    private advance;
+    private check;
+    private match;
+    private skipWhitespace;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private addToken;
+}
+//# sourceMappingURL=lexer.d.ts.map

package/dist/engines/liquid/parser.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Liquid Parser
+ * Converts Liquid tokens to a common AST format
+ * Shopify-compatible implementation
+ */
+import { LiquidToken } from './lexer';
+import type { TemplateNode } from '../../parser/nodes';
+export declare class LiquidParser {
+    private tokens;
+    private current;
+    private source;
+    constructor(tokens: LiquidToken[], source?: string);
+    parse(): TemplateNode;
+    private parseNodes;
+    private parseNode;
+    private parseText;
+    private parseOutput;
+    private parseTag;
+    private parseIfTag;
+    private parseUnlessTag;
+    private parseCaseTag;
+    private parseForTag;
+    private parseForIterable;
+    private parseAssignTag;
+    private parseCaptureTag;
+    private parseIncrementTag;
+    private parseIncludeTag;
+    private parseCommentTag;
+    private parseRawTag;
+    private parseCondition;
+    private parseOr;
+    private parseAnd;
+    private parseComparison;
+    private parseExpression;
+    private parseExpressionAtom;
+    private parsePath;
+    private checkTag;
+    private consumeTag;
+    private checkKeyword;
+    private expectKeyword;
+    private isAtEnd;
+    private peek;
+    private advance;
+    private check;
+    private expect;
+}
+//# sourceMappingURL=parser.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "binja",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "High-performance Jinja2/Django template engine for Bun",
   "main": "dist/index.js",
   "module": "dist/index.js",