@b4moss/hyogen-md 0.12.0 → 0.14.0

package/dist/io/createFsLoader.d.ts

@@ -0,0 +1,6 @@
+import { Loader } from '../types.js';
+export type FsLoaderOptions = {
+    from?: string;
+    via?: "include" | "component" | "extend";
+};
+export declare function createFsLoader(options?: FsLoaderOptions): Loader;

package/dist/io/createNodeLoader.d.ts

@@ -0,0 +1,4 @@
+import { FsLoaderOptions } from './createFsLoader.js';
+import { Loader } from '../types.js';
+export type NodeLoaderOptions = FsLoaderOptions;
+export declare function createNodeLoader(options?: NodeLoaderOptions): Loader;

package/dist/io/isRemotePath.d.ts

@@ -0,0 +1,2 @@
+/** Returns true when path is an http(s) URL. */
+export declare function isRemotePath(path: string): boolean;

package/dist/io/loadDataSources.d.ts

@@ -0,0 +1,8 @@
+import { DataSourcesMap, HyogenContext, Loader } from '../types.js';
+/** Max UTF-8 byte length per data source file (5 MiB). */
+export declare const DATA_SOURCE_MAX_BYTES: number;
+export type LoadDataSourcesOptions = {
+    root?: string;
+    loader?: Loader;
+};
+export declare function loadDataSources(sources: DataSourcesMap, options?: LoadDataSourcesOptions): Promise<HyogenContext>;

package/dist/io/parseCsvFromString.d.ts

@@ -0,0 +1 @@
+export declare function parseCsvFromString(source: string, filePath?: string): Promise<Record<string, string>[]>;

package/dist/io/parseDataFile.d.ts

@@ -0,0 +1 @@
+export declare function parseDataFile(source: string, filePath: string): Promise<unknown>;

package/dist/io/resolveIncludePath.d.ts

@@ -0,0 +1 @@
+export declare function resolveIncludePath(root: string | undefined, includePath: string, documentPath?: string, fromPath?: string, constrainToRoot?: boolean, hyogenPath?: boolean): string;

package/dist/layout/expandExtendsAndBlocks.d.ts

@@ -0,0 +1,19 @@
+import { HyogenContext, HyogenWarning, Loader } from '../types.js';
+import { VisitStack } from '../include/VisitStack.js';
+export type ExpandExtendsAndBlocksOptions = {
+    path?: string;
+    context: HyogenContext;
+    /** Only the updated bindings after `executeDeclarations` (child wins when merging) */
+    declarationUpdates: HyogenContext;
+    loader?: Loader;
+    root?: string;
+    constrainToRoot?: boolean;
+    visitStack: VisitStack;
+    warnings?: HyogenWarning[];
+    inComponent?: boolean;
+};
+export type ExpandExtendsAndBlocksResult = {
+    source: string;
+    context: HyogenContext;
+};
+export declare function expandExtendsAndBlocks(source: string, options: ExpandExtendsAndBlocksOptions): Promise<ExpandExtendsAndBlocksResult>;

package/dist/layout/parseBlockOpener.d.ts

@@ -0,0 +1,8 @@
+export type BlockOpener = {
+    kind: "block";
+    name: string;
+} | {
+    kind: "endblock";
+};
+/** Parses a single line `block <name>` / `endblock`. */
+export declare function parseBlockOpener(line: string, pathForError?: string): BlockOpener;

package/dist/layout/parseBlockStructures.d.ts

@@ -0,0 +1,15 @@
+export type BlockStructure = {
+    name: string;
+    body: string;
+    /** span start (includes opener) */
+    start: number;
+    /** span end (includes closer) */
+    end: number;
+};
+export type ParseBlockStructuresOptions = {
+    path?: string;
+    mode: "layout" | "child";
+    /** child parsing rule: blocks are only allowed when extend exists */
+    hasExtend?: boolean;
+};
+export declare function parseBlockStructures(source: string, options: ParseBlockStructuresOptions): BlockStructure[];

package/dist/layout/parseExtendBlock.d.ts

@@ -0,0 +1,12 @@
+export type ExtendBlockParseResult = {
+    path: string;
+    /** remaining lines after `extend <path>` (declaration source) */
+    declarationsSource: string;
+};
+/**
+ * Parses an `@hg` block that begins with `extend <path>` and (optionally)
+ * contains declaration lines after it.
+ *
+ * Returns null when the first non-empty line isn't an `extend`.
+ */
+export declare function parseExtendBlock(inner: string, pathForError?: string): ExtendBlockParseResult | null;

package/dist/layout/parseExtendDirective.d.ts

@@ -0,0 +1,5 @@
+export type ExtendDirective = {
+    path: string;
+};
+/** Parses a single line `extend <path>` directive. Returns null when non-extend. */
+export declare function parseExtendDirective(line: string, pathForError?: string): ExtendDirective | null;

package/dist/logic/executeDeclaration.d.ts

@@ -0,0 +1,6 @@
+import { Declaration, HyogenContext } from '../types.js';
+export type ExecuteDeclarationOptions = {
+    path?: string;
+    constBindings?: Set<string>;
+};
+export declare function executeDeclaration(declaration: Declaration, context: HyogenContext, options?: ExecuteDeclarationOptions): Promise<void>;

package/dist/logic/executeDeclarations.d.ts

@@ -0,0 +1,6 @@
+import { ExecuteDeclarationsResult, HyogenContext } from '../types.js';
+export type ExecuteDeclarationsOptions = {
+    path?: string;
+    context?: HyogenContext;
+};
+export declare function executeDeclarations(source: string, options?: ExecuteDeclarationsOptions): Promise<ExecuteDeclarationsResult>;

package/dist/logic/executeStatement.d.ts

@@ -0,0 +1,10 @@
+import { HyogenContext, Statement } from '../types.js';
+export type ExecuteStatementOptions = {
+    path?: string;
+    constBindings?: Set<string>;
+    onUpdate?: (name: string) => void;
+    /** Accumulates stringified `echo` outputs in document order. */
+    echoChunks?: string[];
+};
+export declare function executeStatement(statement: Statement, context: HyogenContext, options?: ExecuteStatementOptions): Promise<void>;
+export declare function executeStatementList(statements: Statement[], context: HyogenContext, options?: ExecuteStatementOptions): Promise<void>;

package/dist/logic/hgBlockUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function extractHgBlockLines(inner: string): string[];
+export declare function isControlDirectiveLine(line: string): boolean;
+export declare function isSingleLineControlBlock(inner: string): boolean;

package/dist/logic/parseDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Declaration, ExprNode } from '../types.js';
+export declare function parseDeclaration(source: string, path?: string): Declaration;
+export declare function parseDeclarationStatements(source: string, path?: string): Declaration[];
+export declare function isDeclarationSource(source: string): boolean;
+export type { ExprNode };

package/dist/logic/parseStatement.d.ts

@@ -0,0 +1,3 @@
+import { Statement } from '../types.js';
+export declare function parseStatementList(source: string, path?: string): Statement[];
+export declare function isExecutableBlockSource(source: string): boolean;

package/dist/logic/reservedWords.d.ts

@@ -0,0 +1,2 @@
+export declare const RESERVED_WORDS: Set<string>;
+export declare function isReservedWord(name: string): boolean;

package/dist/logic/stripComments.d.ts

@@ -0,0 +1,2 @@
+/** Strip // line comments and block comments, preserving string/template contents. */
+export declare function stripComments(source: string): string;

package/dist/markdown/shiftHeadings.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Markdown heading helpers for include/component hierarchy shifting.
+ * ATX + Setext; code fences (``` / ~~~) are excluded.
+ */
+export type FenceState = {
+    active: boolean;
+    marker: "`" | "~" | null;
+    length: number;
+};
+export declare function createFenceState(): FenceState;
+/** Update fence state for a single line; returns whether the line is inside a fence (including fence markers). */
+export declare function consumeFenceLine(state: FenceState, line: string): boolean;
+export declare function parseAtxHeadingLevel(line: string): number | null;
+export declare function parseSetextUnderlineLevel(line: string): number | null;
+/**
+ * Return the heading level of the nearest heading before the end of `prefix`.
+ * Returns 0 when none found.
+ */
+export declare function findPrecedingHeadingLevel(prefix: string): number;
+/**
+ * Shift all headings in `markdown` by `shift` levels (clamped to 6).
+ * Setext headings are normalized to ATX when shift is applied (shift > 0).
+ * When shift <= 0, returns markdown unchanged.
+ */
+export declare function shiftMarkdownHeadings(markdown: string, shift: number): string;

package/dist/parse/hgMarkers.d.ts

@@ -0,0 +1,5 @@
+export type HgMarkerKind = "hg" | "at-at" | "mixed" | "unclosed" | "none";
+/** Classifies hyogen marker usage inside an HTML comment body. */
+export declare function classifyHgMarkers(inner: string): HgMarkerKind;
+/** Strips @hg/@endhg/@@ markers from a hyogen comment inner body. */
+export declare function stripHgMarkers(inner: string): string;

package/dist/parse/parseComponentDirective.d.ts

@@ -0,0 +1,6 @@
+export type ComponentDirective = {
+    kind: "component";
+    path: string;
+    alias: string;
+};
+export declare function parseComponentDirective(inner: string, path?: string): ComponentDirective;

package/dist/parse/parseIncludeDirective.d.ts

@@ -0,0 +1,2 @@
+import { IncludeDirective } from '../types.js';
+export declare function parseIncludeDirective(inner: string, path?: string): Pick<IncludeDirective, "kind" | "path">;

package/dist/parse/scanHgBlocks.d.ts

@@ -0,0 +1,10 @@
+import { HgBlock } from '../types.js';
+/** Finds complete hyogen HTML comment blocks in document order. */
+export declare function scanHgBlocks(source: string): HgBlock[];
+/**
+ * Detects unclosed or mixed hyogen markers inside HTML comments (execute stage).
+ * Mixed `@hg`/`@@` markers are treated as invalid (same as unclosed for callers).
+ */
+export declare function findUnclosedHgBlock(source: string): boolean;
+/** Returns a parse_error message when markers are mixed or unclosed. */
+export declare function describeHgBlockMarkerError(source: string): string | null;

package/dist/paths/assertWithinRootDir.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNormalizedPathWithinRoot(resolvedPath: string, rootDir: string, documentPath?: string): void;
+export declare function assertWithinRootDir(resolvedPath: string, rootDir: string, documentPath?: string): void;

package/dist/paths/findDocRoot.d.ts

@@ -0,0 +1 @@
+export declare function findDocRoot(startPath: string): string | undefined;

package/dist/paths/resolveRenderInput.d.ts

@@ -0,0 +1,11 @@
+export type ResolvedRenderInput = {
+    source: string;
+    rootDir?: string;
+    entryPath?: string;
+    constrainToRoot?: boolean;
+};
+export declare function resolveRenderInput(input: string | {
+    path: string;
+}, options?: {
+    root?: string;
+}): Promise<ResolvedRenderInput>;

package/dist/paths/resolveTemplatePath.d.ts

@@ -0,0 +1,9 @@
+export type ResolveTemplatePathOptions = {
+    rootDir?: string;
+    fromPath?: string;
+    documentPath?: string;
+    constrainToRoot?: boolean;
+    /** When true, `/` paths are hyogen root-relative (require doc root). */
+    hyogenPath?: boolean;
+};
+export declare function resolveTemplatePath(templatePath: string, options?: ResolveTemplatePathOptions): string;

package/dist/pipeline/applyFrontMatterOutputOption.d.ts

@@ -0,0 +1,4 @@
+export declare function applyFrontMatterOutputOption(markdown: string, options: {
+    preserveFrontMatter?: boolean;
+    rawFrontMatter?: string;
+}): string;

package/dist/pipeline/executeHgBlocks.d.ts

@@ -0,0 +1,9 @@
+import { ComponentRegistry } from '../component/ComponentRegistry.js';
+import { ExecuteHgBlocksResult, HyogenContext } from '../types.js';
+export declare function createIncludeMarker(index: number): string;
+export type ExecuteHgBlocksOptions = {
+    path?: string;
+    registry?: ComponentRegistry;
+    context?: HyogenContext;
+};
+export declare function executeHgBlocks(source: string, options?: ExecuteHgBlocksOptions): ExecuteHgBlocksResult;

package/dist/pipeline/joinRemovalSeam.d.ts

@@ -0,0 +1,12 @@
+/** Counts trailing `\n` characters. */
+export declare function countTrailingNewlines(text: string): number;
+/** Counts leading `\n` characters. */
+export declare function countLeadingNewlines(text: string): number;
+/**
+ * Joins `left` and `right` after a removed directive span.
+ * Keeps max(trailing left newlines, leading right newlines) so removal does
+ * not invent an extra blank line, while author blank lines are preserved.
+ */
+export declare function joinRemovalSeam(left: string, right: string): string;
+/** Newline characters dropped by {@link joinRemovalSeam} (for offset tracking). */
+export declare function removalSeamNewlineDelta(left: string, right: string): number;

package/dist/pipeline/renderDocument.d.ts

@@ -0,0 +1,22 @@
+import { HyogenContext, HyogenWarning, RenderOptions, RenderResult } from '../types.js';
+import { ComponentRegistry } from '../component/ComponentRegistry.js';
+import { VisitStack } from '../include/VisitStack.js';
+export type RenderDocumentOptions = RenderOptions & {
+    path?: string;
+    context?: HyogenContext;
+    registry?: ComponentRegistry;
+    warnings?: HyogenWarning[];
+    visitStack?: VisitStack;
+    /** When true, renders through the `component` path (extend is skipped with warning). */
+    inComponent?: boolean;
+};
+export type RenderDocumentBodyOptions = RenderDocumentOptions & {
+    context: HyogenContext;
+};
+export declare function renderDocumentBody(body: string, options: RenderDocumentBodyOptions): Promise<string>;
+export declare function renderDocument(source: string, options?: RenderDocumentOptions): Promise<RenderResult>;
+export type RenderChildDocumentOptions = Omit<RenderDocumentOptions, "context"> & {
+    context: HyogenContext;
+};
+/** Renders an included child document through the full pipeline. */
+export declare function renderChildDocument(source: string, options: RenderChildDocumentOptions): Promise<string>;

package/dist/pipeline/stripHgComments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes complete hyogen HTML comment blocks from source.
+ * At each removal seam, joins surrounding newline runs with max(left, right)
+ * so directive removal does not invent an extra blank line, while author
+ * blank lines around the comment are preserved.
+ */
+export declare function stripHgComments(source: string, preserveHgComments?: boolean): string;

package/dist/renderClient.d.ts

@@ -0,0 +1,15 @@
+import { DataSourcesMap, HyogenContext, RenderOptions, RenderResult } from './types.js';
+type ClientRenderOptions = RenderOptions & {
+    /** Rejected on client — use renderServer/build instead */
+    serverContext?: HyogenContext;
+    /** Rejected on client — use renderServer/build instead */
+    dataSources?: DataSourcesMap;
+};
+/**
+ * Client-side render entry. Requires an injected loader; never uses
+ * createNodeLoader / resolveRenderInput (no FS or network in the library).
+ */
+export declare function renderClient(input: string | {
+    path: string;
+}, context?: HyogenContext, options?: ClientRenderOptions): Promise<RenderResult>;
+export {};

package/dist/renderServer.d.ts

@@ -0,0 +1,4 @@
+import { HyogenContext, RenderResult, ServerRenderOptions } from './types.js';
+export declare function renderServer(input: string | {
+    path: string;
+}, context?: HyogenContext, options?: ServerRenderOptions): Promise<RenderResult>;

package/dist/security/forbiddenKeys.d.ts

@@ -0,0 +1,3 @@
+export declare const FORBIDDEN_KEYS: Set<string>;
+export declare function isForbiddenKey(key: string): boolean;
+export declare function assertSafeMemberAccess(property: string, path?: string): void;

package/dist/security/scanSuspiciousContext.d.ts

@@ -0,0 +1,6 @@
+import { HyogenContext, HyogenWarning } from '../types.js';
+/**
+ * Recursively scans context string leaves for suspicious patterns.
+ * Does not mutate context values; only appends warnings.
+ */
+export declare function scanSuspiciousContext(context: HyogenContext, warnings: HyogenWarning[], path?: string): void;

package/dist/shims/fs-browser.d.ts

@@ -0,0 +1,6 @@
+/** Browser shim — node:fs must not be used on the client entry. */
+export declare function existsSync(_path: string): boolean;
+export declare function statSync(_path: string): never;
+export declare const realpathSync: {
+    native(_path: string): string;
+};

package/dist/shims/fs-promises-browser.d.ts

@@ -0,0 +1,5 @@
+/** Browser shim — node:fs/promises must not be used on the client entry. */
+export declare function readFile(_path: string, _encoding?: string): Promise<string>;
+export declare function stat(_path: string): Promise<never>;
+export declare function mkdir(_path: string, _options?: unknown): Promise<void>;
+export declare function writeFile(_path: string, _data: string): Promise<void>;

package/dist/toc/expandToc.d.ts

@@ -0,0 +1,8 @@
+export type ExpandTocOptions = {
+    path?: string;
+};
+/**
+ * Replace toc directives with Markdown TOC lists (pipeline step 7).
+ * Headings are taken once from the pre-replacement source.
+ */
+export declare function expandToc(source: string, options?: ExpandTocOptions): string;

package/dist/toc/extractHeadings.d.ts

@@ -0,0 +1,10 @@
+export type ExtractedHeading = {
+    level: number;
+    text: string;
+    explicitId?: string;
+};
+/**
+ * Extract ATX / Setext headings from Markdown.
+ * Skips fenced code (``` / ~~~), HTML comments, and hyogen blocks (comments).
+ */
+export declare function extractHeadings(source: string): ExtractedHeading[];

package/dist/toc/formatTocMarkdown.d.ts

@@ -0,0 +1,7 @@
+import { ExtractedHeading } from './extractHeadings.js';
+/**
+ * Build a nested Markdown TOC list from headings.
+ * Anchors are assigned for *all* headings (document order) before filtering by maxLevel,
+ * so duplicate suffixes match full-document GitHub IDs.
+ */
+export declare function formatTocMarkdown(headings: ExtractedHeading[], maxLevel: number): string;

package/dist/toc/githubHeadingSlug.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GitHub-compatible heading slug (no external deps).
+ * Explicit IDs are used as-is; otherwise lowercase, strip punctuation, spaces→`-`.
+ * Duplicate base slugs get `-1`, `-2`, … suffixes (GitHub behavior).
+ */
+export type HeadingSlugger = {
+    slug(text: string, explicitId?: string): string;
+};
+export declare function createHeadingSlugger(): HeadingSlugger;
+/** One-shot slug without duplicate tracking. */
+export declare function githubSlugify(text: string): string;

package/dist/toc/parseTocDirective.d.ts

@@ -0,0 +1,10 @@
+export type TocDirective = {
+    maxLevel: number;
+};
+/** True when a single line looks like a toc directive (args validated later). */
+export declare function isTocDirectiveLine(line: string): boolean;
+/**
+ * Parses a toc / toc(N) directive from a block inner or a single source line.
+ * N defaults to 6; must be an integer 1–6 when present.
+ */
+export declare function parseTocDirective(source: string, path?: string): TocDirective;

package/dist/toc/plainifyHeadingText.d.ts

@@ -0,0 +1,2 @@
+/** Strip common Markdown decorations from heading display text. */
+export declare function plainifyHeadingText(text: string): string;

package/dist/types.d.ts

@@ -0,0 +1,211 @@
+export type HyogenContext = Record<string, unknown>;
+export type HyogenDiagnostic = {
+    code: string;
+    message: string;
+    path?: string;
+    details?: Record<string, unknown>;
+};
+export type HyogenWarning = HyogenDiagnostic;
+export type HyogenError = Error & HyogenDiagnostic;
+export type Loader = (path: string) => Promise<string>;
+export type DataSourcesMap = Record<string, string>;
+export type RenderOptions = {
+    preserveFrontMatter?: boolean;
+    preserveHgComments?: boolean;
+    loader?: Loader;
+    root?: string;
+    path?: string;
+    constrainToRoot?: boolean;
+};
+export type ServerRenderOptions = RenderOptions & {
+    serverContext?: HyogenContext;
+    /** Variable name → root-relative data file path (YAML / JSON / CSV). */
+    dataSources?: DataSourcesMap;
+};
+export type RenderResult = {
+    markdown: string;
+    warnings: HyogenWarning[];
+};
+export type BuildOptions = RenderOptions & {
+    input: string | string[];
+    outDir: string;
+    includeUnderscoreEntries?: boolean;
+    context?: HyogenContext;
+    serverContext?: HyogenContext;
+    dataSources?: DataSourcesMap;
+};
+export type BuildResult = {
+    files: {
+        path: string;
+        markdown: string;
+    }[];
+    warnings: HyogenWarning[];
+};
+export type HgBlock = {
+    start: number;
+    end: number;
+    inner: string;
+    raw: string;
+};
+export type IncludeDirective = {
+    kind: "include";
+    path: string;
+    marker: string;
+    raw?: string;
+};
+export type ComponentDirective = {
+    kind: "component";
+    path: string;
+    alias: string;
+};
+export type ParseFrontMatterResult = {
+    context: HyogenContext;
+    body: string;
+    rawFrontMatter?: string;
+};
+export type ExecuteHgBlocksResult = {
+    source: string;
+    directives: IncludeDirective[];
+};
+export type BinaryOp = "+" | "-" | "*" | "/" | "===" | "!==" | "==" | "!=" | ">=" | "<=" | ">" | "<" | "&&" | "||";
+export type ExprNode = {
+    type: "identifier";
+    name: string;
+} | {
+    type: "literal";
+    value: unknown;
+} | {
+    type: "member";
+    object: ExprNode;
+    property: string;
+} | {
+    type: "default";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    type: "call";
+    callee: string;
+    args: Record<string, ExprNode>;
+} | {
+    type: "method";
+    object: ExprNode;
+    method: string;
+    args: unknown[];
+} | {
+    type: "unary";
+    op: "!";
+    operand: ExprNode;
+} | {
+    type: "binary";
+    op: BinaryOp;
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    type: "ternary";
+    condition: ExprNode;
+    consequent: ExprNode;
+    alternate: ExprNode;
+} | {
+    type: "template";
+    parts: Array<string | ExprNode>;
+};
+export type Declaration = {
+    kind: "const";
+    name: string;
+    expr: ExprNode;
+} | {
+    kind: "let";
+    name: string;
+    expr: ExprNode;
+} | {
+    kind: "assign";
+    name: string;
+    expr: ExprNode;
+};
+export type CompoundAssignOp = "+=" | "-=" | "*=" | "/=";
+export type Statement = Declaration | {
+    kind: "for";
+    init: Statement | null;
+    cond: ExprNode;
+    update: Statement | null;
+    body: Statement[];
+} | {
+    kind: "do_while";
+    body: Statement[];
+    cond: ExprNode;
+} | {
+    kind: "update";
+    name: string;
+    op: "++" | "--";
+    position: "prefix" | "postfix";
+} | {
+    kind: "compound_assign";
+    name: string;
+    op: CompoundAssignOp;
+    expr: ExprNode;
+} | {
+    kind: "echo";
+    expr: ExprNode;
+};
+export type ControlOpener = {
+    kind: "if";
+    expr: ExprNode;
+} | {
+    kind: "else_if";
+    expr: ExprNode;
+} | {
+    kind: "else";
+} | {
+    kind: "endif";
+} | {
+    kind: "each";
+    item: string;
+    expr: ExprNode;
+} | {
+    kind: "endeach";
+};
+export type ControlBlockSpan = {
+    start: number;
+    end: number;
+    raw: string;
+};
+export type IfBranch = {
+    kind: "if" | "else_if" | "else";
+    expr?: ExprNode;
+    opener: ControlBlockSpan;
+    body: ControlNode[];
+};
+export type ControlNode = {
+    kind: "text";
+    content: string;
+} | {
+    kind: "if";
+    branches: IfBranch[];
+    closer: ControlBlockSpan;
+} | {
+    kind: "each";
+    item: string;
+    expr: ExprNode;
+    opener: ControlBlockSpan;
+    body: ControlNode[];
+    closer: ControlBlockSpan;
+};
+export type ExecuteDeclarationsResult = {
+    source: string;
+    context: HyogenContext;
+    /** Updated bindings caused by executed declaration blocks. */
+    declarationUpdates?: HyogenContext;
+};
+export type EvaluateExpressionOptions = {
+    context: HyogenContext;
+    path?: string;
+    registry?: import('./component/ComponentRegistry.js').ComponentRegistry;
+    loader?: Loader;
+    rootDir?: string;
+    warnings?: HyogenWarning[];
+    visitStack?: import('./include/VisitStack.js').VisitStack;
+    parentContext?: HyogenContext;
+    preserveHgComments?: boolean;
+    constrainToRoot?: boolean;
+};
+export type InterpolateExpressionsOptions = EvaluateExpressionOptions;