marko 6.4.4 → 6.4.6

package/dist/translator/util/analyze-errors.d.ts

@@ -1,3 +1,4 @@
 import type { types as t } from "@marko/compiler";
+declare const hasAnalyzeErrors: () => boolean;
+export { hasAnalyzeErrors };
 export declare function reportAnalyzeError(path: t.NodePath<t.Node>, error: unknown): void;
-export declare function hasAnalyzeErrors(): boolean;

package/dist/translator/util/assert.d.ts

@@ -1,4 +1,11 @@
-import type { types as t } from "@marko/compiler";
+import { types as t } from "@marko/compiler";
 export declare function assertNoSpreadAttrs(tag: t.NodePath<t.MarkoTag>): void;
+export declare function assertOnlyValueAttr(tag: t.NodePath<t.MarkoTag>, required: true, change?: boolean, hint?: (attr: t.MarkoAttribute) => string | undefined): t.MarkoAttribute;
+export declare function assertOnlyValueAttr(tag: t.NodePath<t.MarkoTag>, required?: boolean, change?: boolean, hint?: (attr: t.MarkoAttribute) => string | undefined): t.MarkoAttribute | undefined;
+export declare function assertHasVar(tag: t.NodePath<t.MarkoTag>, hint?: string | ((tag: t.NodePath<t.MarkoTag>) => string)): void;
+export declare function assertIdentifierVar(tag: t.NodePath<t.MarkoTag>): void;
 export declare function assertNoTagVarMutation(tag: t.NodePath<t.MarkoTag>): void;
+export declare function assertHasBody(tag: t.NodePath<t.MarkoTag>): void;
 export declare function assertNoBodyContent(tag: t.NodePath<t.MarkoTag>): void;
+export declare function buildAttrsError(tag: t.NodePath<t.MarkoTag>, attrs: t.MarkoTag["attributes"], msg: string): Error;
+export declare function buildAttrNameError(tag: t.NodePath<t.MarkoTag>, attr: t.MarkoAttribute, msg: string): Error;

package/dist/translator/util/bindings.d.ts

@@ -29,11 +29,12 @@ export interface Binding {
     /** The expressions its value is computed from, `false` for none; unset when
      * analysis cannot see them, which makes it its own source. */
     derivedFrom: Opt<t.NodeExtra> | false;
-    /** Complete only once `finalizeReferences` runs at program analyze exit. */
-    /** Its reads, by the expression each is in; pruning hands an expression's reads
-     * to the nearest ancestor it also reads, which they then resolve to. */
+    /** Its reads by expression, complete once `finalizeReferences` runs: pruning
+     * hands an expression's reads to the nearest ancestor it also reads. */
     reads: Map<ReferencedExtra, Opt<Read>>;
     aliases: Set<Binding>;
+    /** The sections reading it through a hoist: its own or its ancestors, so
+     * the first is the outermost. */
     hoists: SortedOpt<Section>;
     getters: Map<Getter["hoisted"], boolean>;
     property: string | undefined;
@@ -75,7 +76,7 @@ export interface Binding {
     /** In a template's or `<define>`'s params tree, which known call sites set
      * directly. */
     exposed: boolean;
-    /** Read on invocation from its own scope slot, which must persist. */
+    /** Read on invocation from its own scope slot, so its signal stores it. */
     hasLazyReads: boolean;
 }
 /** A param of a template or of a tag body, which its caller supplies. */
@@ -102,26 +103,28 @@ export interface Getter {
 export declare const getBindings: () => Set<Binding>;
 export declare function createBinding(name: string, type: Binding["type"], refSection: Section, aliased?: Binding["aliasOf"], property?: string, excludeProperties?: SortedOpt<string>, loc?: t.SourceLocation | null, refDeclared?: boolean, restOffset?: number): Binding;
 export declare function reserveId(binding: Binding, offset: ReservedId): void;
-export declare function getOrCreatePropertyAlias(binding: Binding, property: string): Binding;
+export declare function ensurePropertyAlias(binding: Binding, property: string): Binding;
 export declare function addAssignedProperty(binding: Binding, property: string | undefined): void;
 export declare function getAssignedObject(binding: Binding): Binding | undefined;
-export declare function getPropertyAlias(binding: Binding | undefined, properties: Opt<string>): Binding | undefined;
+export declare function getPropertyAlias(binding: Binding, properties: Opt<string>): Binding | undefined;
+export declare function getDeepestPropertyAlias(binding: Binding, properties: Opt<string>): Binding;
 export declare function compareReferences(a: ReferencedBindings, b: ReferencedBindings): number;
 /**
  * reference group priority is sorted by number of references,
  * then if needed by reference order.
  */
 export declare function compareIntersections(a: Intersection, b: Intersection): number;
-export declare function getAliasRoot(binding: Binding): Binding | undefined;
+export declare function getAliasRoot(binding: Binding): Binding;
 export declare const bindingUtil: Sorted<Binding>;
 export declare const propsUtil: Sorted<string>;
 export declare function getCanonicalBinding(binding: Binding): Binding;
 export declare function someAlias<A>(binding: Binding, test: (binding: Binding, arg: A) => boolean, arg: A, directOnly?: boolean): boolean;
-export declare function someAliased<A>(binding: Binding | undefined, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
+export declare function someUpToAliasRoot<A>(binding: Binding | undefined, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
 export declare function getNearestDeclared(binding: Binding): Binding | undefined;
+export declare function getDeclaredAlias(binding: Binding): false | Binding | undefined;
 export declare function isDirectAlias(binding: Binding): boolean;
 export declare function isRest(binding: Binding): boolean;
-export declare function getDebugScopeAccess(binding: Binding): {
+export declare function getDebugAccess(binding: Binding, toParam: boolean, formatProperty: (property: string) => string): {
     root: Binding;
     access: string;
 };
@@ -130,6 +133,7 @@ export declare function getDebugName(binding: Binding): string;
 export declare function getDebugNames(refs: ReferencedBindings): string;
 export declare function getDebugNamesAsIdentifier(refs: ReferencedBindings): string;
 export declare function isInvokeOnlyBinding(binding: Binding): boolean;
+export declare function isOwnBinding(binding: Binding): boolean;
 export declare function hasNonConstantPropertyAlias(ref: Binding): boolean;
 export declare function getPropertyPath(binding: Binding, ancestor: Binding): Opt<string>;
 export declare function isIndexProperty(property: string): boolean;

package/dist/translator/util/body-to-text.d.ts

@@ -0,0 +1,9 @@
+import { types as t } from "@marko/compiler";
+declare module "@marko/compiler/dist/types" {
+    interface MarkoPlaceholderExtra {
+        needsTextCoercion?: true;
+    }
+}
+export declare function bodyToText(body: t.MarkoTagBody, decodeEntities?: boolean): t.ArrayExpression | t.ArrowFunctionExpression | t.AssignmentExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.BindExpression | t.BooleanLiteral | t.CallExpression | t.ClassExpression | t.ConditionalExpression | t.DecimalLiteral | t.DoExpression | t.FunctionExpression | t.Identifier | t.Import | t.ImportExpression | t.JSXElement | t.JSXFragment | t.LogicalExpression | t.MarkoParseError | t.MemberExpression | t.MetaProperty | t.ModuleExpression | t.NewExpression | t.NullLiteral | t.NumericLiteral | t.ObjectExpression | t.OptionalCallExpression | t.OptionalMemberExpression | t.ParenthesizedExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.PipelineTopicExpression | t.RecordExpression | t.RegExpLiteral | t.SequenceExpression | t.StringLiteral | t.Super | t.TSAsExpression | t.TSInstantiationExpression | t.TSNonNullExpression | t.TSSatisfiesExpression | t.TSTypeAssertion | t.TaggedTemplateExpression | t.TemplateLiteral | t.ThisExpression | t.TopicReference | t.TupleExpression | t.TypeCastExpression | t.UnaryExpression | t.UpdateExpression | t.YieldExpression;
+export declare function bodyToUncoercedText(body: t.MarkoTagBody): t.ArrayExpression | t.ArrowFunctionExpression | t.AssignmentExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.BindExpression | t.BooleanLiteral | t.CallExpression | t.ClassExpression | t.ConditionalExpression | t.DecimalLiteral | t.DoExpression | t.FunctionExpression | t.Identifier | t.Import | t.ImportExpression | t.JSXElement | t.JSXFragment | t.LogicalExpression | t.MarkoParseError | t.MemberExpression | t.MetaProperty | t.ModuleExpression | t.NewExpression | t.NullLiteral | t.NumericLiteral | t.ObjectExpression | t.OptionalCallExpression | t.OptionalMemberExpression | t.ParenthesizedExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.PipelineTopicExpression | t.RecordExpression | t.RegExpLiteral | t.SequenceExpression | t.StringLiteral | t.Super | t.TSAsExpression | t.TSInstantiationExpression | t.TSNonNullExpression | t.TSSatisfiesExpression | t.TSTypeAssertion | t.TaggedTemplateExpression | t.TemplateLiteral | t.ThisExpression | t.TopicReference | t.TupleExpression | t.TypeCastExpression | t.UnaryExpression | t.UpdateExpression | t.YieldExpression;
+export declare function injectTextCoercion(expr: t.Expression): void;

package/dist/translator/util/branch-tag.d.ts

@@ -3,8 +3,15 @@ import { type Binding } from "./bindings";
 import { type Reasons } from "./reasons";
 import { type Section } from "./sections";
 export declare function initBranchSection(bodySection: Section, branchExpr: Section["branchExpr"], branch: NonNullable<Section["branch"]>): void;
-export declare function resumeOwnerByMarkerWhenStatic(bodySection: Section, nodeBinding: Binding): void;
-export declare function getBranchResumeArgs(tagSection: Section, nodeBinding: Binding, branchReasons: Reasons, onlyChildParentTagName: string | false | undefined, singleNode: boolean): (t.Expression | undefined)[];
-export declare function getBranchEndArgs(tagSection: Section, nodeBinding: Binding, onlyChildParentTagName: string | false | undefined, singleNode: boolean | undefined): (t.Expression | undefined)[];
+export declare function resumeOwnerByMarkerWhenUnconditional(bodySection: Section, nodeBinding: Binding): void;
+export declare function getBranchResumeArgs(tag: t.NodePath<t.MarkoTag>, branchReasons: Reasons, singleNode: boolean): (t.Expression | undefined)[];
+export declare function buildBranchEndArgs(tagSection: Section, nodeBinding: Binding, onlyChildParentTagName: string | false | undefined, singleNode: boolean | undefined): (t.Expression | undefined)[];
 export declare function isEndTagWrittenByBranch(nodeBinding: Binding | undefined): boolean;
 export declare function isSingleNodeBranch(bodySection: Section | undefined): boolean;
+export type ForType = "in" | "of" | "to" | "until";
+export declare function buildForRuntimeCall(type: ForType, attrs: Record<string, t.Expression>, params: t.ArrowFunctionExpression["params"], statements: t.Statement[]): t.ExpressionStatement;
+export declare function getForType(tag: t.MarkoTag): ForType | undefined;
+export declare function forTypeToRuntime(type: ForType): "forIn" | "forOf" | "forTo" | "forUntil";
+export declare function forTypeToBranchRuntime(type: ForType): "_for_in" | "_for_of" | "_for_to" | "_for_until";
+export declare function forTypeToUnkeyedBranchRuntime(type: ForType): "_for_of_unkeyed" | "_for_to_unkeyed" | "_for_until_unkeyed";
+export declare function getBaseArgsInForTag(type: ForType, attrs: Record<string, t.Expression>): t.Expression[];

package/dist/translator/util/build-string-expression.d.ts

@@ -0,0 +1,4 @@
+import { types as t } from "@marko/compiler";
+export default function buildStringExpression(parts: (string | t.Expression)[], useIife?: boolean): t.Expression | undefined;
+export declare function appendLiteral(arr: unknown[], str: string): void;
+export declare function toTemplateElement(value: string, tail?: boolean): t.TemplateElement;

package/dist/translator/util/content-derives.d.ts

@@ -0,0 +1,7 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
+import { type Opt } from "./optional";
+import { type KnownExprs } from "./reasons";
+import { type Section } from "./sections";
+export declare function setTagContentDerives(tag: t.NodePath<t.MarkoTag>, binding: Opt<Binding>, exprs?: KnownExprs): void;
+export declare function finalizeContentDerives(section: Section): void;

package/dist/translator/util/entry-builder.d.ts

@@ -9,29 +9,40 @@ declare module "@marko/compiler/dist/types" {
 }
 interface EntryState {
     init: boolean;
-    load: boolean;
+    hasClientStatement: boolean;
     /** Whether a reached template lazily imports another. */
     lazy: boolean;
     /** Depth of enclosing templates whose modules the bundle already loads:
      * below a root everything arrives through its imports, and a lazy subtree
      * is loaded by its own load entry. */
-    bundled: number;
+    bundledDepth: number;
+    /** Depth of enclosing lazy imports, whose load entries bring their assets. */
+    lazyDepth: number;
     roots: string[];
     /** Assets of templates the bundle never loads; the entry imports them. */
     assets: Set<string>;
     /** Assets that arrive through a bundled template's imports; the entry
      * imports them itself only when it links nothing (a server only page). */
     bundledAssets: Set<string>;
-    /** Whether each reached file was only ever seen below a bundled template. */
-    visited: Map<string, boolean>;
+    /** The most eager way each file has been reached. */
+    visited: Map<string, Reach>;
 }
+/** How a file was reached: 0 eagerly, 1 below a bundled template, 2 only
+ * within a lazy subtree. Lower is more eager, so `seen <= reach` means it was
+ * already visited at least as eagerly and is skipped; a file reached more
+ * eagerly than before is re-visited, since it may then own assets or a root. */
+export type Reach = 0 | 1 | 2;
 type EntryFile = t.BabelFile & {
     [kState]?: EntryState;
 };
-type VisitChild = (id: string, bundled?: boolean) => void;
+type VisitChild = (id: string, reach?: Reach) => void;
 declare const kState: unique symbol;
 declare const builder: {
     build(entryFile: EntryFile, exportInit?: boolean): t.Statement[];
     visit(file: t.BabelFile, entryFile: EntryFile, visitChild?: VisitChild): void;
 };
 export default builder;
+export declare function assertVisited<S>(entryFile: t.BabelFile, state: S | undefined): asserts state is S;
+export declare function createVisited(entryFile: t.BabelFile): Map<string, Reach>;
+export declare function resolveRelativeToEntry(entryFile: t.BabelFile, file: t.BabelFile, req: string): string;
+export declare function markReached(visited: Map<string, Reach>, resolved: string, reach: Reach): boolean;

package/dist/translator/util/finalize-references.d.ts

@@ -1,4 +1,5 @@
-import { type Binding, type ReferencedBindings } from "./bindings";
+import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
 export declare function finalizeReferences(): void;
-export declare function getValueInputs(binding: Binding): ReferencedBindings;
+export declare function readsValuesOnResume(expr: t.NodeExtra): boolean;
 export declare function hasEmittedAssignment(binding: Binding): boolean;

package/dist/translator/util/generate-uid.d.ts

@@ -8,6 +8,7 @@ declare module "@marko/compiler/dist/types" {
 }
 export declare function generateUid(name?: string): string;
 export declare function generateUidIdentifier(name?: string): t.Identifier;
-export declare function getSharedUid(name: string, section?: Section): string;
-export declare function usedSharedUid(name: string): boolean;
+export declare function declareConstBefore(tag: t.NodePath<t.MarkoTag>, name: string, expr: t.Expression): t.Identifier;
+export declare function ensureSharedUid(name: string, section?: Section): string;
+export declare function hasSharedUid(name: string): boolean;
 export {};

package/dist/translator/util/get-root.d.ts

@@ -1,8 +1,8 @@
 import type { types as t } from "@marko/compiler";
-export type MarkoExprRootPath = t.NodePath<t.MarkoTag | t.MarkoTagBody | t.MarkoAttribute | t.MarkoSpreadAttribute | t.MarkoScriptlet | t.MarkoPlaceholder | t.ExportNamedDeclaration | t.ExportDefaultDeclaration>;
-export declare function getMarkoRoot(path: t.NodePath<t.Node>): MarkoExprRootPath | null;
+export type MarkoRootPath = t.NodePath<t.MarkoTag | t.MarkoTagBody | t.MarkoAttribute | t.MarkoSpreadAttribute | t.MarkoScriptlet | t.MarkoPlaceholder | t.ExportNamedDeclaration | t.ExportDefaultDeclaration>;
+export declare function getMarkoRoot(path: t.NodePath<t.Node>): MarkoRootPath | null;
 export declare function getExprRoot(path: t.NodePath<t.Node>): t.NodePath<t.Node>;
 export declare function getFnRoot(path: t.NodePath<t.Node>): t.NodePath<t.ArrowFunctionExpression | t.FunctionDeclaration | t.FunctionExpression | t.ObjectMember> | undefined;
 export declare function getFnParent(path: t.NodePath<t.Node>): t.NodePath<t.ArrowFunctionExpression | t.FunctionDeclaration | t.FunctionExpression | t.ObjectMember> | undefined;
 export declare function getDeclarationRoot(path: t.NodePath<t.Node>): t.NodePath<t.FunctionDeclaration | t.VariableDeclaration> | undefined;
-export declare function isMarko(path: t.NodePath<any>): path is MarkoExprRootPath;
+export declare function isMarkoRoot(path: t.NodePath<any>): path is MarkoRootPath;

package/dist/translator/util/get-tag-name.d.ts

@@ -1,3 +1,3 @@
 import { types as t } from "@marko/compiler";
 export declare function getTagName<T extends t.MarkoTag>(tag: t.NodePath<T>): T["name"] extends t.StringLiteral ? string : string | undefined;
-export declare function getStaticTagName(node: t.MarkoTag): string;
+export declare function getTagNameHint(node: t.MarkoTag): string;

package/dist/translator/util/known-tag.d.ts

@@ -1,23 +1,25 @@
 import { types as t } from "@marko/compiler";
-import { type BindingPropTree } from "./binding-prop-tree";
 import { type Binding } from "./bindings";
-import { type KnownExprs } from "./references";
+import { type ParamsTree } from "./params-tree";
+import { type KnownExprs } from "./reasons";
 import { type Section } from "./sections";
-declare const kContentSection: unique symbol;
-declare const kPropTree: unique symbol;
+declare const kChildSection: unique symbol;
+declare const kParamsTree: unique symbol;
 declare const kKnownExprs: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
-        [kContentSection]?: Section;
+        /** The dom binding a known tag holds its child's scope in. */
+        childScopeBinding?: Binding;
+        [kChildSection]?: Section;
         /** The child's params tree the call site was analyzed against. */
-        [kPropTree]?: BindingPropTree;
+        [kParamsTree]?: ParamsTree;
         [kKnownExprs]?: KnownExprs;
     }
 }
-export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, contentSection: Section, childParamsTree?: BindingPropTree): void;
+export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, childSection: Section, childParamsTree?: ParamsTree): void;
 export declare function analyzeRecursiveTags(): void;
 export declare function knownTagTranslateHTML(tag: t.NodePath<t.MarkoTag>, tagIdentifier: t.Expression): void;
 export declare function knownTagTranslateDOM(tag: t.NodePath<t.MarkoTag>, getBindingIdentifier: (binding: Binding, preferredName?: string, directContent?: boolean) => t.Identifier, callSetup: ((section: Section, childBinding: Binding) => void) | undefined): void;
-export declare function finalizeKnownTags(section: Section): void;
+export declare function addKnownTagReasons(section: Section): void;
 export declare function callsOtherTemplateSetup(section: Section): boolean;
 export {};

package/dist/translator/util/module-read.d.ts

@@ -12,9 +12,6 @@ export interface ModuleRead {
     /** The import's source; none for a `<style/name>` tag's own stylesheet module. */
     request: string | undefined;
 }
-/** The module read an expression is, resolved on first use: translate replaces
- * a `<style/name>` tag. */
-export declare function getModuleRead(path: t.NodePath, expr: t.Expression): ModuleRead | undefined;
 /** A module read of a stylesheet module, whose reads are class name strings. */
 export declare function getStyleImportRead(path: t.NodePath, expr: t.Expression): string[] | undefined;
 export declare function toModuleReadExpression([name, ...members]: string[]): t.Identifier | t.MemberExpression;

package/dist/translator/util/module-registrations.d.ts

@@ -1,7 +1,51 @@
 import { types as t } from "@marko/compiler";
+import { type MarkoRootPath } from "./get-root";
+import { type RegisteredFnExtra } from "./references";
+declare const kRegisteredExports: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        [kRegisteredExports]?: Map<string, RegisteredExport>;
+    }
+    interface ImportDeclarationExtra {
+        /** Each local binding the template registers -> the export it imports. */
+        registeredImports?: Map<string, RegisteredExport>;
+    }
+}
+/**
+ * An export registered under an id: the template that declares it, and the
+ * canonical name it is exported under.
+ */
+export interface RegisteredExport {
+    registerId: string;
+    exportName: string;
+    filename: string;
+}
+export declare function trackFunction(fn: t.NodePath<t.Function>, fnExtra: RegisteredFnExtra, markoRoot: MarkoRootPath): void;
+export declare function canIgnoreRegister(markoRoot: MarkoRootPath, exprRoot: t.NodePath<t.Node>): boolean;
+export declare function addFunctionReasons(): void;
+export declare function finalizeRegistrations(): void;
+/**
+ * Tracks a template imported as a default export. The server writes a template
+ * only as a binding's value, so the importing template registers it when one may.
+ */
+export declare function trackImportedTemplate(importDecl: t.NodePath<t.ImportDeclaration>, local: string, templateFile: t.BabelFile): void;
+/**
+ * Tracks an export imported from another template that registers under an id,
+ * if it does. The importing template registers it (under that id) when client
+ * code reads its own references.
+ */
+export declare function trackImport(importDecl: t.NodePath<t.ImportDeclaration>, local: string, registered: RegisteredExport | undefined, fnRoots?: Set<t.NodeExtra>): void;
+/**
+ * Finds the id reserved for an export, following `export ... from` hops. Each
+ * template only records the exports it declares, so this resolves on demand:
+ * a template in an import cycle is read while it is still analyzing, and would
+ * hand out an incomplete map if the ids were pushed ahead of time.
+ */
+export declare function resolveRegisteredExport(file: t.BabelFile, exportName: string, seen?: Set<string>): RegisteredExport | undefined;
 /**
  * Writes the registrations for module scoped functions: the ones this template
  * exports and registers itself, and the ones it imports from a template that
  * reserved a register id without registering it; and for templates it imports.
  */
 export declare function writeModuleRegistrations(program: t.NodePath<t.Program>): void;
+export {};

package/dist/translator/util/nested-attribute-tags.d.ts

@@ -9,7 +9,7 @@ export type AttrTagLookup = Record<string, AttrTagMeta>;
 type AttrTagNames = string[];
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
-        attributeTags?: AttrTagLookup;
+        attrTagLookup?: AttrTagLookup;
         attributeTagGroup?: AttrTagLookup[string]["group"];
     }
 }

package/dist/translator/util/optional.d.ts

@@ -14,10 +14,13 @@ export declare class Sorted<T> {
     add<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): SortedOneMany<U>;
     union<U extends NonNullable<T>>(a: SortedOpt<U>, b: SortedOpt<U>): SortedOpt<U>;
     filter<U extends NonNullable<T>>(data: SortedOpt<U>, cb: (item: U) => boolean): SortedOpt<U>;
+    leadingRun<U extends NonNullable<T>, K>(data: SortedOpt<U>, key: (item: U) => K, compareKeys: Compare<K>, bound: K): SortedOpt<U>;
+    range<U extends NonNullable<T>, K>(data: SortedOpt<U>, key: (item: U) => K, compareKeys: Compare<K>, bound: K): SortedOpt<U>;
+    forEachRun<U extends NonNullable<T>, K>(data: SortedOpt<U>, key: (item: U) => K, compareKeys: Compare<K>, fn: (key: K, run: SortedOneMany<U>) => void): void;
+    reduceRuns<U extends NonNullable<T>, K, R>(data: SortedOpt<U>, key: (item: U) => K, compareKeys: Compare<K>, fn: (acc: R, key: K, run: SortedOneMany<U>) => R, initial: R): R;
     find<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): U | undefined;
     has<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): boolean;
     findIndex<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): number;
-    groupBy<U extends NonNullable<T>, K>(data: SortedOpt<U>, cb: (item: U) => K): Map<K, SortedOneMany<U>>;
     intersects<U extends NonNullable<T>>(a: SortedOpt<U>, b: SortedOpt<U>): boolean;
     difference<U extends NonNullable<T>>(a: SortedOpt<U>, b: SortedOpt<U>): SortedOpt<U>;
     isSuperset<U extends NonNullable<T>>(superset: SortedOpt<U>, subset: SortedOpt<U>): boolean;
@@ -33,6 +36,7 @@ export declare function some<T>(data: Opt<T>, cb: (item: T, index: number) => bo
 export declare function every<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): boolean;
 export declare function reduce<T, R>(data: Opt<T>, cb: (acc: R | undefined, item: T, index: number) => R | undefined): R | undefined;
 export declare function reduce<T, R>(data: Opt<T>, cb: (acc: R, item: T, index: number) => R, initial: R): R;
+export declare function reduceWhile<T, R>(data: Opt<T>, cb: (acc: R, item: T) => R | undefined, initial: R): R | undefined;
 export declare function toArray<T, R>(data: Opt<T>, cb: (item: T, index: number) => R): R[];
 export declare function toSet<T>(data: Opt<T>): Set<T>;
 export declare function mapToString<T>(data: Opt<T>, sep: string, cb: (item: T, index: number) => string): string;
@@ -41,5 +45,6 @@ export declare function findIndexSorted<T>(compare: Compare<T>, data: T[], item:
 export declare function addSorted<T, U extends T[]>(compare: Compare<T>, data: U, item: T): U;
 export declare function at<T>(data: Opt<T>, index: number): T | undefined;
 export declare function first<T>(data: OneMany<T>): T;
+export declare function last<T>(data: OneMany<T>): T;
 export declare function rest<T>(data: OneMany<T>): Opt<T>;
 export {};

package/dist/translator/util/params-tree.d.ts

@@ -0,0 +1,18 @@
+import { type Binding } from "./bindings";
+export type ParamsTree = {
+    binding: Binding;
+    props: {
+        [prop: string]: ParamsTree;
+    } | undefined;
+    rest: ParamsTree | undefined;
+};
+declare module "@marko/compiler/dist/types" {
+    interface NodeExtra {
+        nameOnly?: true;
+    }
+}
+export declare function exposeParamsTree(binding: Binding, bodyAnalyzed?: boolean): ParamsTree;
+export declare function getSettledParamsTree(paramsTree: ParamsTree | undefined): ParamsTree | undefined;
+export declare function getParamsTreeAt(paramsTree: ParamsTree | true, name: string): ParamsTree | true | undefined;
+export declare function getAllKnownPropNames(paramsTree: ParamsTree): string[];
+export declare function hasAllKnownProps(paramsTree: ParamsTree): boolean | undefined;

package/dist/translator/util/reasons.d.ts

@@ -1,14 +1,13 @@
 import { types as t } from "@marko/compiler";
-import { type ReferencedBindings } from "./bindings";
-import { type Opt, Sorted, type SortedOneMany } from "./optional";
-import { type KnownExprs } from "./references";
+import { type Binding, type ParamBinding, type ReferencedBindings } from "./bindings";
+import { type Opt, type SortedOneMany } from "./optional";
 import { type ParamReasonGroups, type Section } from "./sections";
 import { type Slot } from "./slots";
 import { type Sources } from "./sources";
 export type Reasons = SortedOneMany<Sources>;
-export declare const sourcesUtil: Sorted<Sources>;
 export type Reason = Sources;
 export declare function addReason(slot: Slot, reason: undefined | false | Reason): void;
+export declare function addAlwaysReason(binding: Binding): void;
 export declare function addReasonExprs(slot: Slot, expr: Opt<t.NodeExtra>): void;
 export declare function addOwnerReason(from: Section, to: Section, reason: undefined | false | Reason): void;
 export declare function isConditionalReason(reason: undefined | Reason): reason is Sources & {
@@ -22,11 +21,14 @@ export declare function getSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): S
 export declare function getSourcesForRef(ref: ReferencedBindings): Sources | undefined;
 export declare function getSourcesForDerived({ binding, exprs, properties, }: NonNullable<Section["derives"]>): Sources | undefined;
 export declare function mapParamReason(program: Section, reason: Sources, exprs: KnownExprs | undefined, ownParams: boolean): Reason | undefined;
-export declare function mergeReasons(a: Reason, b: undefined | Reason): Reason;
-export declare function mergeReasons(a: undefined | Reason, b: Reason): Reason;
-export declare function mergeReasons(a: undefined | Reason, b: undefined | Reason): Reason | undefined;
+export interface KnownExprs {
+    known?: Record<string, KnownExprs>;
+    value?: t.NodeExtra;
+}
+export declare function mapParamReasonToExpr(exprs: KnownExprs, reason: boolean | Opt<ParamBinding>): true | import("./optional").Many<t.NodeExtra> | t.NodeExtra | undefined;
+export declare function mapParamBindingToExpr(exprs: KnownExprs, binding: ParamBinding): Opt<t.NodeExtra>;
 export declare function applyReasonExprs(section: Section): void;
-export declare function finalizeReason(section: Section): void;
+export declare function mergeSlotReasons(section: Section): void;
 export declare function getNodeReasons(section: Section): Sources | import("./optional").SortedMany<Sources> | undefined;
 export declare function getReasonsVersion(): number;
 export declare function setParamReasonGroups(section: Section, groups: ParamReasonGroups): void;

package/dist/translator/util/references.d.ts

@@ -1,30 +1,30 @@
 import { types as t } from "@marko/compiler";
-import { type Binding, BindingType, type Getter, type ParamBinding, type ReferencedBindings } from "./bindings";
+import { type Binding, BindingType, type Getter, type ReferencedBindings } from "./bindings";
 import { type OneMany, type Opt, type SortedOpt } from "./optional";
-import { type Reason } from "./reasons";
+import { type KnownExprs, type Reason } from "./reasons";
 import { type Section } from "./sections";
 interface ReferencedFunctionExtra extends t.FunctionExtra, ReferencedExtra {
 }
 export interface Read {
     binding: Binding;
     extra: t.NodeExtra;
-    ownVar: boolean;
+    inOwnBody: boolean;
     getter: Getter | undefined;
     comparedTo: t.Node | undefined;
     deferred: boolean;
-    inFunction: boolean;
+    /** The outermost function holding it; none when that escapes into a call. */
+    fnRoot: ReferencedFunctionExtra | undefined;
 }
-export interface ExtraRead {
+export interface ResolvedRead {
     binding: Binding;
     props: Opt<string>;
-    ownVar: boolean;
+    inOwnBody: boolean;
     getter: Getter | undefined;
     /** Set for same-section local reads: the function root that owns the read. */
     localFn?: ReferencedFunctionExtra;
 }
 declare const kReferencedBindings: unique symbol;
 declare const kLazyBindings: unique symbol;
-declare const kGlobalBindings: unique symbol;
 declare const kReferencedBindingsInFunction: unique symbol;
 declare const kConstantBindingsInFunction: unique symbol;
 declare module "@marko/compiler/dist/types" {
@@ -33,8 +33,8 @@ declare module "@marko/compiler/dist/types" {
         hasGlobalRead?: true;
     }
     interface MarkoTagExtra {
-        /** The dom binding the tag is addressed by: its node, marker or child
-         * scope; an only child control flow tag shares its parent's. */
+        /** The dom binding the tag is addressed by: its node or marker; an only
+         * child control flow tag shares its parent's. */
         nodeBinding?: Binding;
     }
     interface MarkoPlaceholderExtra {
@@ -45,11 +45,10 @@ declare module "@marko/compiler/dist/types" {
         section?: Section;
         [kReferencedBindings]?: ReferencedBindings;
         [kLazyBindings]?: ReferencedBindings;
-        [kGlobalBindings]?: ReferencedBindings;
-        /** The bindings it feeds, in the order it feeds them: a call site's
-         * values feed the child template's, so no one template's order sorts them. */
+        /** The bindings it derives, in the order it derives them: call sites
+         * derive a child template's, so no one template's order sorts them. */
         derives?: Opt<Binding>;
-        /** The initial value of the binding it feeds, which keeps it rather than
+        /** The initial value of the binding it derives, which keeps it rather than
          * following it, so the binding derives no sources from it. */
         initialValue?: true;
         /** Its value has no side effect to evaluate, so an unread one can go: an
@@ -61,8 +60,8 @@ declare module "@marko/compiler/dist/types" {
         binding?: Binding;
         assignment?: Binding;
         assignmentTo?: Binding;
-        read?: ExtraRead;
-        pruned?: true;
+        read?: ResolvedRead;
+        dropped?: true;
         /** The expression this node sits in: dropped or merged as one. */
         exprRoot?: NodeExtra;
         isEffect?: true;
@@ -104,12 +103,12 @@ export declare function isTagVarUsed(tag: t.NodePath<t.MarkoTag>): boolean;
 export declare function trackDomVarReferences(tag: t.NodePath<t.MarkoTag>, binding: Binding): Binding | undefined;
 export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: BindingType, aliased?: Binding["aliasOf"]): Binding | undefined;
 export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType): Binding | undefined;
-export declare function isReferenceInOwnBody(bindingPath: t.NodePath, reference: t.NodePath): boolean;
 export declare function isReferenceHoisted(bindingPath: t.NodePath, reference: t.NodePath): boolean;
-export declare function assertReferencedInRender(ref: t.NodePath, name: string, markoRoot?: import("./get-root").MarkoExprRootPath | null): void;
+export declare function assertReferencedInRender(ref: t.NodePath, name: string, markoRoot?: import("./get-root").MarkoRootPath | null): void;
 export declare function setReferencesScope(path: t.NodePath<any>): void;
 export declare function trackGlobalReference(path: t.NodePath<t.Identifier>): void;
 export declare function mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]> & ReferencedExtra;
+export declare function mergeTagReferences(section: Section, tag: t.MarkoTag): t.MarkoTagExtra & t.NodeExtra & ReferencedExtra;
 export declare function mergeReferenceGroup(section: Section, nodes: (t.Node | undefined)[]): ReferencedExtra;
 export declare function setDerivedFrom(binding: Binding, expr: boolean | Opt<t.NodeExtra>, exprs?: KnownExprs): void;
 export declare const getAssignments: () => AssignedBindingExtra[];
@@ -122,8 +121,8 @@ export declare function dropNodes(node: t.Node | t.Node[]): void;
 export declare function dropExtra(exprExtra: ReferencedExtra): void;
 export declare function dropContent(body: t.MarkoTagBody): void;
 export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[], collectAttrTag?: (attrTag: t.MarkoTag) => void): t.Node[];
-export declare function createRead(binding: Binding, props: Opt<string>, ownVar?: boolean): ExtraRead;
-export declare function createGetterRead(binding: Binding, props: Opt<string>, getter: Getter): ExtraRead;
+export declare function createResolvedRead(binding: Binding, props: Opt<string>, inOwnBody?: boolean): ResolvedRead;
+export declare function createResolvedGetterRead(binding: Binding, props: Opt<string>, getter: Getter): ResolvedRead;
 export interface ReferencedExtra extends t.NodeExtra {
     section: Section;
 }
@@ -134,26 +133,22 @@ export interface AssignedBindingExtra extends ReferencedExtra {
     /** The outermost function holding it; none when that escapes into a call. */
     fnRoot: ReferencedFunctionExtra | undefined;
 }
-export declare function hasResumableWriter(binding: Binding): boolean;
+export declare function hasResumableAssignment(binding: Binding): boolean;
 export declare function isAssignedBindingExtra(extra: t.NodeExtra | undefined): extra is AssignedBindingExtra;
 export interface RegisteredFnExtra extends ReferencedExtra, t.FunctionExtra {
+    exprRoot: t.NodeExtra;
     name: string;
     registerId: string;
     reason: Reason;
 }
 export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): extra is RegisteredFnExtra;
 export declare function getReferencedBindings(extra: t.NodeExtra | undefined): ReferencedBindings;
+export declare function getBindingsDerivedFrom(binding: Binding): ReferencedBindings;
+export declare function getValueReferences(exprs: Opt<t.NodeExtra>): ReferencedBindings;
 export declare function getLazyBindings(extra: t.NodeExtra | undefined): ReferencedBindings;
-export declare function getGlobalBindings(extra: t.NodeExtra | undefined): ReferencedBindings;
 export declare function getReferencedBindingsInFunction(extra: t.FunctionExtra): ReferencedBindings;
 export declare function getConstantBindingsInFunction(extra: t.FunctionExtra): ReferencedBindings;
 export declare function setResolvedFunctionReads(extra: t.FunctionExtra, referencedBindings: ReferencedBindings, constantBindings: ReferencedBindings): void;
-export declare function setResolvedReads(extra: ReferencedExtra, referencedBindings: ReferencedBindings, lazyBindings: ReferencedBindings, globalBindings: ReferencedBindings): void;
+export declare function setResolvedReads(extra: ReferencedExtra, referencedBindings: ReferencedBindings, lazyBindings: ReferencedBindings): void;
 export declare function getCanonicalExtra<T extends t.NodeExtra>(extra: T): T;
-export interface KnownExprs {
-    known?: Record<string, KnownExprs>;
-    value?: t.NodeExtra;
-}
-export declare function mapParamReasonToExpr(exprs: KnownExprs, reason: boolean | Opt<ParamBinding>): true | import("./optional").Many<t.NodeExtra> | t.NodeExtra | undefined;
-export declare function mapParamBindingToExpr(exprs: KnownExprs, binding: ParamBinding): Opt<t.NodeExtra>;
 export {};

package/dist/translator/util/runtime.d.ts

@@ -1,7 +1,5 @@
 import { types as t } from "@marko/compiler";
 import type { Falsy } from "../../common/types";
-import { _attr, _attr_class, _attr_style, _escape, _escape_script, _escape_style, _unescaped } from "../../html";
-import { escapeDoubleQuotedAttrValue } from "../../html/attrs";
 export type DOMRuntimeHelpers = keyof typeof import("../../dom");
 export type HTMLRuntimeHelpers = keyof typeof import("../../html");
 export declare function importRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers): t.Identifier;
@@ -12,15 +10,5 @@ export declare const domRuntimeFeatures: readonly ["catch", "controllable", "con
 export type DOMRuntimeFeature = (typeof domRuntimeFeatures)[number];
 export declare function importRuntimeFeature(feature: DOMRuntimeFeature): void;
 export declare function getRuntimeFeatureImport(feature: DOMRuntimeFeature): t.ImportDeclaration;
-export declare function getHTMLRuntime(): {
-    _escape: typeof _escape;
-    _unescaped: typeof _unescaped;
-    _attr: typeof _attr;
-    _attr_class: typeof _attr_class;
-    _attr_style: typeof _attr_style;
-    _escape_script: typeof _escape_script;
-    _escape_style: typeof _escape_style;
-    escapeDoubleQuotedAttrValue: typeof escapeDoubleQuotedAttrValue;
-};
 export declare function getRuntimePath(output: string): string;
 export declare function getCompatRuntimeFile(): string;

package/dist/translator/util/scope-accessor.d.ts

@@ -10,5 +10,4 @@ export declare function getScopeAccessor(binding: Binding, encoded?: boolean, in
 export declare function getLocalsScopeAccessor(binding: Binding): string;
 export declare function getPrefixedScopeAccessor(binding: Binding, prefix: AccessorPrefix): string;
 export declare function getClosureAccessorLiteral(binding: Binding): t.NumericLiteral | t.StringLiteral;
-export declare function getSectionInstancesAccessor(section: Section): string;
 export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral;

package/dist/translator/util/scope-read.d.ts

@@ -1,5 +1,8 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "./bindings";
 import type { Section } from "./sections";
+export declare let scopeIdentifier: t.Identifier;
+export declare let localsIdentifier: t.Identifier;
+export declare function createScopeIdentifiers(): void;
 export declare function getScopeExpression(section: Section, targetSection: Section): t.Identifier | t.MemberExpression;
 export declare function createScopeReadExpression(reference: Binding, section?: Section): t.MemberExpression;

package/dist/translator/util/section-renderer.d.ts

@@ -0,0 +1,4 @@
+import { types as t } from "@marko/compiler";
+import type { Section } from "./sections";
+export declare function getSectionRendererIdentifier(section: Section): t.Identifier | undefined;
+export declare function isSectionRendererElided(section: Section): boolean;