@syncular/typegen 0.4.0 → 0.5.0

package/dist/syql-parser.js

@@ -0,0 +1,604 @@
+/** Revision-1 SYQL container parser (`docs/SYQL.md` §3). */
+import { isSyqlTrivia, lexSyqlSource, SyqlFrontendError, } from './syql-lexer.js';
+import { parseSyqlEmbeddedTemplate, } from './syql-template-parser.js';
+const CAMEL_IDENT_RE = /^[a-z][A-Za-z0-9]*$/;
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const INTEGER_LITERAL_RE = /^(?:0|[1-9][0-9]*)$/;
+const BASE_TYPES = new Set([
+    'string',
+    'integer',
+    'float',
+    'boolean',
+    'json',
+    'bytes',
+    'blob_ref',
+    'crdt',
+]);
+const RESERVED_NAMES = new Set([
+    'as',
+    'blob_ref',
+    'boolean',
+    'by',
+    'bytes',
+    'cover',
+    'crdt',
+    'default',
+    'float',
+    'from',
+    'identity',
+    'import',
+    'in',
+    'integer',
+    'json',
+    'max',
+    'null',
+    'page',
+    'predicate',
+    'query',
+    'scope',
+    'sort',
+    'sql',
+    'string',
+    'switch',
+    'when',
+]);
+function spanBetween(start, end) {
+    return {
+        file: start.span.file,
+        start: start.span.start,
+        end: end.span.end,
+    };
+}
+function spanFromPositions(file, start, end) {
+    return { file, start, end };
+}
+class Parser {
+    #file;
+    #source;
+    #tokens;
+    #index = 0;
+    constructor(file, source) {
+        this.#file = file;
+        this.#source = source;
+        this.#tokens = lexSyqlSource(file, source);
+    }
+    parse() {
+        const imports = [];
+        const declarations = [];
+        const predicates = [];
+        const queries = [];
+        const fileNames = new Map();
+        let sawDeclaration = false;
+        while (this.#peek().kind !== 'eof') {
+            const keyword = this.#peek();
+            if (keyword.text === 'import') {
+                if (sawDeclaration) {
+                    this.#fail('SYQL2008_INVALID_MEMBER', keyword, 'imports must precede all predicate and query declarations');
+                }
+                const declaration = this.#parseImport();
+                for (const item of declaration.items) {
+                    this.#claimName(fileNames, item.local, item.span, 'imported name');
+                }
+                imports.push(declaration);
+                continue;
+            }
+            sawDeclaration = true;
+            if (keyword.text === 'predicate') {
+                const declaration = this.#parsePredicate();
+                this.#claimName(fileNames, declaration.name, declaration.nameSpan, 'declaration');
+                declarations.push(declaration);
+                predicates.push(declaration);
+            }
+            else if (keyword.text === 'query') {
+                const declaration = this.#parseQuery();
+                this.#claimName(fileNames, declaration.name, declaration.nameSpan, 'declaration');
+                declarations.push(declaration);
+                queries.push(declaration);
+            }
+            else {
+                this.#fail('SYQL2008_INVALID_MEMBER', keyword, `expected import, predicate, or query; found ${JSON.stringify(keyword.text)}`);
+            }
+        }
+        const first = this.#tokens[0];
+        const eof = this.#tokens[this.#tokens.length - 1];
+        return {
+            kind: 'file',
+            file: this.#file,
+            source: this.#source,
+            tokens: this.#tokens,
+            imports,
+            declarations,
+            predicates,
+            queries,
+            span: spanFromPositions(this.#file, first.span.start, eof.span.end),
+        };
+    }
+    #parseImport() {
+        const start = this.#expectText('import');
+        this.#expectText('{');
+        const items = [];
+        const localNames = new Map();
+        const importedNames = new Map();
+        if (this.#peek().text === '}') {
+            this.#fail('SYQL2005_INVALID_IMPORT', this.#peek(), 'an import list must contain at least one predicate name');
+        }
+        for (;;) {
+            const importedToken = this.#parseCamelName('imported predicate name');
+            this.#claimName(importedNames, importedToken.text, importedToken.span, 'imported predicate');
+            let localToken = importedToken;
+            if (this.#peek().text === 'as') {
+                this.#take();
+                localToken = this.#parseCamelName('import alias');
+            }
+            this.#claimName(localNames, localToken.text, localToken.span, 'import alias');
+            items.push({
+                imported: importedToken.text,
+                local: localToken.text,
+                span: spanBetween(importedToken, localToken),
+            });
+            if (this.#peek().text !== ',')
+                break;
+            this.#take();
+            if (this.#peek().text === '}')
+                break;
+        }
+        this.#expectText('}');
+        this.#expectText('from');
+        const pathToken = this.#take();
+        if (pathToken.kind !== 'import-path') {
+            this.#fail('SYQL2005_INVALID_IMPORT', pathToken, 'expected a JSON double-quoted relative .syql import path');
+        }
+        let path;
+        try {
+            path = JSON.parse(pathToken.text);
+        }
+        catch {
+            this.#fail('SYQL2005_INVALID_IMPORT', pathToken, 'invalid JSON import path');
+        }
+        if (typeof path !== 'string' ||
+            (!path.startsWith('./') && !path.startsWith('../')) ||
+            !path.endsWith('.syql') ||
+            path.includes('\0') ||
+            path.includes('\\')) {
+            this.#fail('SYQL2005_INVALID_IMPORT', pathToken, 'import path must be a slash-separated relative path ending in .syql');
+        }
+        const end = this.#expectText(';');
+        return { kind: 'import', items, path, span: spanBetween(start, end) };
+    }
+    #parsePredicate() {
+        const start = this.#expectText('predicate');
+        const name = this.#parseCamelName('predicate name');
+        this.#expectText('(');
+        const parameters = [];
+        const names = new Map();
+        if (this.#peek().text !== ')') {
+            for (;;) {
+                const paramStart = this.#parseCamelName('predicate parameter');
+                const type = this.#peek().text === ':' ? this.#parseTypeAnnotation() : undefined;
+                const span = spanFromPositions(this.#file, paramStart.span.start, (type?.span ?? paramStart.span).end);
+                this.#claimName(names, paramStart.text, paramStart.span, 'predicate parameter');
+                parameters.push({
+                    name: paramStart.text,
+                    ...(type === undefined ? {} : { type }),
+                    span,
+                    nameSpan: paramStart.span,
+                });
+                if (this.#peek().text !== ',')
+                    break;
+                this.#take();
+                if (this.#peek().text === ')')
+                    break;
+            }
+        }
+        this.#expectText(')');
+        const body = this.#parseTemplateBlock('predicate body', 'predicate');
+        return {
+            kind: 'predicate',
+            name: name.text,
+            parameters,
+            body: body.template,
+            span: spanBetween(start, body.close),
+            nameSpan: name.span,
+        };
+    }
+    #parseQuery() {
+        const start = this.#expectText('query');
+        const name = this.#parseCamelName('query name');
+        const parsedParameters = this.#parseQueryParameters();
+        const publicNames = parsedParameters.publicNames;
+        this.#expectText('{');
+        if (this.#peek().text !== 'sql') {
+            this.#fail('SYQL2008_INVALID_MEMBER', this.#peek(), 'a query body must begin with exactly one sql { ... } section');
+        }
+        const sql = this.#parseSqlSection();
+        let sort;
+        let page;
+        let identity;
+        if (this.#peek().text === 'sort') {
+            sort = this.#parseSortSection(publicNames);
+        }
+        if (this.#peek().text === 'page') {
+            page = this.#parsePageDeclaration(publicNames);
+        }
+        if (this.#peek().text === 'identity') {
+            identity = this.#parseIdentityDeclaration();
+        }
+        if (this.#peek().text !== '}') {
+            this.#fail('SYQL2008_INVALID_MEMBER', this.#peek(), `unexpected or out-of-order query member ${JSON.stringify(this.#peek().text)}`);
+        }
+        const close = this.#expectText('}');
+        return {
+            kind: 'query',
+            name: name.text,
+            parameters: parsedParameters.parameters,
+            sql,
+            ...(sort === undefined ? {} : { sort }),
+            ...(page === undefined ? {} : { page }),
+            ...(identity === undefined ? {} : { identity }),
+            span: spanBetween(start, close),
+            nameSpan: name.span,
+        };
+    }
+    #parseQueryParameters() {
+        this.#expectText('(');
+        const parameters = [];
+        const publicNames = new Set();
+        const bindNames = new Set();
+        if (this.#peek().text !== ')') {
+            for (;;) {
+                const name = this.#parseCamelName('query parameter');
+                const optional = this.#peek().text === '?';
+                if (optional)
+                    this.#take();
+                if (optional && this.#peek().text === '(') {
+                    if (publicNames.has(name.text)) {
+                        this.#duplicate(name, 'public query input');
+                    }
+                    publicNames.add(name.text);
+                    this.#take();
+                    const members = [];
+                    for (;;) {
+                        const memberName = this.#parseCamelName('group member');
+                        if (memberName.text === name.text) {
+                            this.#fail('SYQL2011_INVALID_PARAMETER', memberName, `group ${name.text} cannot contain a member with the same name`);
+                        }
+                        if (bindNames.has(memberName.text)) {
+                            this.#duplicate(memberName, 'query bind');
+                        }
+                        bindNames.add(memberName.text);
+                        const type = this.#peek().text === ':'
+                            ? this.#parseTypeAnnotation()
+                            : undefined;
+                        members.push({
+                            name: memberName.text,
+                            ...(type === undefined ? {} : { type }),
+                            span: spanFromPositions(this.#file, memberName.span.start, (type?.span ?? memberName.span).end),
+                            nameSpan: memberName.span,
+                        });
+                        if (this.#peek().text !== ',')
+                            break;
+                        this.#take();
+                        if (this.#peek().text === ')')
+                            break;
+                    }
+                    const groupClose = this.#expectText(')');
+                    if (members.length < 2) {
+                        this.#fail('SYQL2011_INVALID_PARAMETER', name, `group ${name.text} must contain at least two members`);
+                    }
+                    parameters.push({
+                        kind: 'group',
+                        name: name.text,
+                        optional: true,
+                        members,
+                        span: spanFromPositions(this.#file, name.span.start, groupClose.span.end),
+                        nameSpan: name.span,
+                    });
+                }
+                else {
+                    if (publicNames.has(name.text)) {
+                        this.#duplicate(name, 'public query input');
+                    }
+                    publicNames.add(name.text);
+                    if (this.#peek().text === ':') {
+                        const colon = this.#take();
+                        const typeName = this.#expectKind('identifier', 'parameter type');
+                        if (typeName.text === 'switch') {
+                            if (!optional) {
+                                this.#fail('SYQL2011_INVALID_PARAMETER', typeName, `switch ${name.text} must use the exact optional form ${name.text}?: switch`);
+                            }
+                            parameters.push({
+                                kind: 'switch',
+                                name: name.text,
+                                optional: true,
+                                span: spanBetween(name, typeName),
+                                nameSpan: name.span,
+                            });
+                        }
+                        else {
+                            const type = this.#parseValueTypeAfterName(colon, typeName);
+                            if (bindNames.has(name.text)) {
+                                this.#duplicate(name, 'query bind');
+                            }
+                            bindNames.add(name.text);
+                            parameters.push({
+                                kind: 'value',
+                                name: name.text,
+                                optional,
+                                type,
+                                span: spanFromPositions(this.#file, name.span.start, type.span.end),
+                                nameSpan: name.span,
+                            });
+                        }
+                    }
+                    else {
+                        if (bindNames.has(name.text)) {
+                            this.#duplicate(name, 'query bind');
+                        }
+                        bindNames.add(name.text);
+                        parameters.push({
+                            kind: 'value',
+                            name: name.text,
+                            optional,
+                            span: spanFromPositions(this.#file, name.span.start, optional
+                                ? this.#previousSignificant().span.end
+                                : name.span.end),
+                            nameSpan: name.span,
+                        });
+                    }
+                }
+                if (this.#peek().text !== ',')
+                    break;
+                this.#take();
+                if (this.#peek().text === ')')
+                    break;
+            }
+        }
+        this.#expectText(')');
+        return { parameters, publicNames, bindNames };
+    }
+    #parseSqlSection() {
+        const start = this.#expectText('sql');
+        const block = this.#parseTemplateBlock('sql section', 'statement');
+        return {
+            kind: 'sql',
+            body: block.template,
+            span: spanBetween(start, block.close),
+        };
+    }
+    #parseSortSection(publicNames) {
+        const start = this.#expectText('sort');
+        const control = this.#parseCamelName('sort control');
+        if (publicNames.has(control.text)) {
+            this.#duplicate(control, 'public query input');
+        }
+        publicNames.add(control.text);
+        this.#expectText('default');
+        const defaultProfile = this.#parseCamelName('default sort profile');
+        this.#expectText('{');
+        const profiles = [];
+        const profileNames = new Set();
+        while (this.#peek().text !== '}') {
+            if (this.#peek().kind === 'eof') {
+                this.#fail('SYQL2001_EXPECTED_TOKEN', this.#peek(), 'expected } to close sort section');
+            }
+            const profileName = this.#parseCamelName('sort profile');
+            if (profileNames.has(profileName.text)) {
+                this.#duplicate(profileName, 'sort profile');
+            }
+            profileNames.add(profileName.text);
+            const order = this.#parseTemplateBlock('sort profile', 'order');
+            profiles.push({
+                name: profileName.text,
+                order: order.template,
+                span: spanBetween(profileName, order.close),
+                nameSpan: profileName.span,
+            });
+        }
+        const close = this.#expectText('}');
+        if (profiles.length === 0) {
+            this.#fail('SYQL2008_INVALID_MEMBER', close, 'a sort section must contain at least one profile');
+        }
+        if (!profileNames.has(defaultProfile.text)) {
+            this.#fail('SYQL2008_INVALID_MEMBER', defaultProfile, `default sort profile ${JSON.stringify(defaultProfile.text)} is not declared`);
+        }
+        return {
+            kind: 'sort',
+            control: control.text,
+            defaultProfile: defaultProfile.text,
+            profiles,
+            span: spanBetween(start, close),
+            controlSpan: control.span,
+        };
+    }
+    #parsePageDeclaration(publicNames) {
+        const start = this.#expectText('page');
+        const control = this.#parseCamelName('page control');
+        if (publicNames.has(control.text)) {
+            this.#duplicate(control, 'public query input');
+        }
+        publicNames.add(control.text);
+        this.#expectText('default');
+        const defaultToken = this.#parseInteger('page default');
+        this.#expectText('max');
+        const maxToken = this.#parseInteger('page maximum');
+        const end = this.#expectText(';');
+        const defaultSize = Number(defaultToken.text);
+        const maxSize = Number(maxToken.text);
+        if (defaultSize < 1 || defaultSize > maxSize || maxSize > 2_147_483_647) {
+            this.#fail('SYQL2010_INVALID_PAGE_RANGE', defaultToken, `page bounds must satisfy 1 <= default <= max <= 2147483647; found default ${defaultSize}, max ${maxSize}`);
+        }
+        return {
+            kind: 'page',
+            control: control.text,
+            defaultSize,
+            maxSize,
+            span: spanBetween(start, end),
+            controlSpan: control.span,
+        };
+    }
+    #parseIdentityDeclaration() {
+        const start = this.#expectText('identity');
+        this.#expectText('by');
+        const fields = [];
+        const names = new Set();
+        for (;;) {
+            const field = this.#expectKind('identifier', 'identity result name');
+            if (!IDENT_RE.test(field.text)) {
+                this.#fail('SYQL2002_INVALID_NAME', field, `invalid identity result name ${JSON.stringify(field.text)}`);
+            }
+            if (names.has(field.text))
+                this.#duplicate(field, 'identity field');
+            names.add(field.text);
+            fields.push(field.text);
+            if (this.#peek().text !== ',')
+                break;
+            this.#take();
+        }
+        const end = this.#expectText(';');
+        return { kind: 'identity', fields, span: spanBetween(start, end) };
+    }
+    #parseTypeAnnotation() {
+        const colon = this.#expectText(':');
+        const name = this.#expectKind('identifier', 'value type');
+        return this.#parseValueTypeAfterName(colon, name);
+    }
+    #parseValueTypeAfterName(colon, name) {
+        if (!BASE_TYPES.has(name.text)) {
+            this.#fail('SYQL2011_INVALID_PARAMETER', name, `unknown value type ${JSON.stringify(name.text)}`);
+        }
+        let end = name;
+        let nullable = false;
+        if (this.#peek().text === '|') {
+            this.#take();
+            end = this.#expectText('null');
+            nullable = true;
+        }
+        return {
+            base: name.text,
+            nullable,
+            span: spanBetween(colon, end),
+        };
+    }
+    #parseInteger(label) {
+        const token = this.#take();
+        if (token.kind !== 'number' || !INTEGER_LITERAL_RE.test(token.text)) {
+            this.#fail('SYQL2009_INVALID_INTEGER', token, `${label} must be a decimal integer literal without sign or separators`);
+        }
+        return token;
+    }
+    #parseTemplateBlock(label, mode) {
+        const open = this.#expectText('{');
+        const contentStart = this.#index;
+        let depth = 1;
+        let cursor = this.#index;
+        while (cursor < this.#tokens.length) {
+            const token = this.#tokens[cursor];
+            if (token.kind === 'eof') {
+                this.#fail('SYQL2001_EXPECTED_TOKEN', token, `expected } to close ${label}`);
+            }
+            if (token.kind === 'punctuation') {
+                if (token.text === '{')
+                    depth += 1;
+                else if (token.text === '}') {
+                    depth -= 1;
+                    if (depth === 0) {
+                        const bodyTokens = this.#tokens.slice(contentStart, cursor);
+                        const semanticTokens = bodyTokens.filter((candidate) => !isSyqlTrivia(candidate));
+                        if (semanticTokens.length === 0) {
+                            this.#fail('SYQL2006_EMPTY_TEMPLATE', token, `${label} must not be empty`);
+                        }
+                        if (semanticTokens.some((candidate) => candidate.kind === 'punctuation' && candidate.text === ';')) {
+                            const semicolon = semanticTokens.find((candidate) => candidate.kind === 'punctuation' && candidate.text === ';');
+                            this.#fail('SYQL2007_FORBIDDEN_SEMICOLON', semicolon, `${label} must not contain a semicolon token`);
+                        }
+                        const templateSpan = spanFromPositions(this.#file, open.span.end, token.span.start);
+                        const tree = parseSyqlEmbeddedTemplate(this.#file, bodyTokens, templateSpan, mode);
+                        this.#index = cursor + 1;
+                        return {
+                            template: {
+                                text: this.#source.slice(open.span.end.offset, token.span.start.offset),
+                                tokens: bodyTokens,
+                                tree,
+                                span: templateSpan,
+                            },
+                            open,
+                            close: token,
+                        };
+                    }
+                }
+            }
+            cursor += 1;
+        }
+        throw new Error('unreachable: token stream always ends in EOF');
+    }
+    #parseCamelName(label) {
+        const token = this.#expectKind('identifier', label);
+        if (!CAMEL_IDENT_RE.test(token.text)) {
+            this.#fail('SYQL2002_INVALID_NAME', token, `${label} must match [a-z][A-Za-z0-9]*; found ${JSON.stringify(token.text)}`);
+        }
+        if (token.text.toLowerCase().startsWith('__syql')) {
+            this.#fail('SYQL2003_RESERVED_NAME', token, `${JSON.stringify(token.text)} uses the reserved __syql prefix`);
+        }
+        if (RESERVED_NAMES.has(token.text)) {
+            this.#fail('SYQL2003_RESERVED_NAME', token, `${JSON.stringify(token.text)} is a reserved SYQL name`);
+        }
+        return token;
+    }
+    #claimName(names, name, span, label) {
+        if (names.has(name)) {
+            throw new SyqlFrontendError('SYQL2004_DUPLICATE_NAME', span, `duplicate ${label} ${JSON.stringify(name)}`);
+        }
+        names.set(name, span);
+    }
+    #duplicate(token, label) {
+        this.#fail('SYQL2004_DUPLICATE_NAME', token, `duplicate ${label} ${JSON.stringify(token.text)}`);
+    }
+    #peek() {
+        let index = this.#index;
+        while (index < this.#tokens.length &&
+            isSyqlTrivia(this.#tokens[index])) {
+            index += 1;
+        }
+        return this.#tokens[index];
+    }
+    #take() {
+        while (this.#index < this.#tokens.length &&
+            isSyqlTrivia(this.#tokens[this.#index])) {
+            this.#index += 1;
+        }
+        const token = this.#tokens[this.#index];
+        this.#index += 1;
+        return token;
+    }
+    #previousSignificant() {
+        let index = this.#index - 1;
+        while (index >= 0) {
+            const token = this.#tokens[index];
+            if (!isSyqlTrivia(token))
+                return token;
+            index -= 1;
+        }
+        return undefined;
+    }
+    #expectText(text) {
+        const token = this.#take();
+        if (token.text !== text) {
+            this.#fail('SYQL2001_EXPECTED_TOKEN', token, `expected ${JSON.stringify(text)}, found ${JSON.stringify(token.text || 'end of file')}`);
+        }
+        return token;
+    }
+    #expectKind(kind, label) {
+        const token = this.#take();
+        if (token.kind !== kind) {
+            this.#fail('SYQL2001_EXPECTED_TOKEN', token, `expected ${label}, found ${JSON.stringify(token.text || 'end of file')}`);
+        }
+        return token;
+    }
+    #fail(code, token, message) {
+        throw new SyqlFrontendError(code, token.span, message);
+    }
+}
+/** Parse one `.syql` file using the destructive revision-1 grammar. */
+export function parseSyqlSyntaxFile(file, source) {
+    return new Parser(file, source).parse();
+}

package/dist/syql-template-parser.d.ts

@@ -0,0 +1,58 @@
+/** Embedded SQL-template node parser for revision-1 SYQL (§§6, 8, and 10). */
+import { type SyqlSourceSpan, type SyqlToken } from './syql-lexer.js';
+export type SyqlTemplateMode = 'statement' | 'predicate' | 'condition' | 'order';
+export interface SyqlRawTemplateNode {
+    readonly kind: 'raw';
+    readonly text: string;
+    readonly tokens: readonly SyqlToken[];
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlBindReference {
+    readonly kind: 'bind-reference';
+    readonly name: string;
+    readonly token: SyqlToken;
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlPredicateCall {
+    readonly kind: 'predicate-call';
+    readonly name: string;
+    readonly arguments: readonly SyqlBindReference[];
+    readonly tokens: readonly SyqlToken[];
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlWhenExpression {
+    readonly kind: 'when';
+    readonly controls: readonly string[];
+    readonly controlSpans: readonly SyqlSourceSpan[];
+    readonly body: SyqlEmbeddedTemplate;
+    readonly tokens: readonly SyqlToken[];
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlQualifiedColumn {
+    readonly qualifier: string;
+    readonly name: string;
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlScopeBinding {
+    readonly kind: 'scope-binding';
+    readonly column: SyqlQualifiedColumn;
+    readonly operator: 'equal' | 'in';
+    readonly values: readonly SyqlBindReference[];
+    readonly span: SyqlSourceSpan;
+}
+export interface SyqlReactiveDirective {
+    readonly kind: 'scope' | 'cover';
+    readonly bindings: readonly SyqlScopeBinding[];
+    readonly tokens: readonly SyqlToken[];
+    readonly span: SyqlSourceSpan;
+}
+export type SyqlEmbeddedNode = SyqlRawTemplateNode | SyqlPredicateCall | SyqlWhenExpression | SyqlReactiveDirective;
+export interface SyqlEmbeddedTemplate {
+    readonly kind: 'template';
+    readonly mode: SyqlTemplateMode;
+    readonly nodes: readonly SyqlEmbeddedNode[];
+    readonly span: SyqlSourceSpan;
+}
+export type SyqlTemplateParseErrorCode = 'SYQL3001_EXPECTED_EMBEDDED_TOKEN' | 'SYQL3002_INVALID_BIND' | 'SYQL3003_INVALID_PREDICATE_CALL' | 'SYQL3004_INVALID_WHEN' | 'SYQL3005_INVALID_REACTIVE_DIRECTIVE' | 'SYQL3006_FORBIDDEN_TEMPLATE_NODE' | 'SYQL3007_UNEXPECTED_BRACE' | 'SYQL3008_FORBIDDEN_PARAMETER_FORM';
+/** Parse embedded nodes from one already-delimited lossless template. */
+export declare function parseSyqlEmbeddedTemplate(file: string, tokens: readonly SyqlToken[], span: SyqlSourceSpan, mode: SyqlTemplateMode): SyqlEmbeddedTemplate;