marko 6.3.56 → 6.4.1

package/dist/translator/util/binding-has-prop.d.ts

@@ -1,6 +1,8 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
 import { type Opt } from "./optional";
-import type { Binding } from "./references";
 import type { Section } from "./sections";
+export declare function getSectionRendererIdentifier(section: Section): t.Identifier | undefined;
 export declare function isSectionRendererElided(section: Section): boolean;
 export declare function bindingHasProperty(binding: Binding, properties: Opt<string>): boolean;
 export declare function getPropertyPathAlias(binding: Binding, properties: Opt<string>): Binding;

package/dist/translator/util/binding-prop-tree.d.ts

@@ -1,4 +1,4 @@
-import { type Binding } from "./references";
+import { type Binding } from "./bindings";
 export type BindingPropTree = {
     binding: Binding;
     props: {
@@ -6,13 +6,13 @@ export type BindingPropTree = {
     } | undefined;
     rest: BindingPropTree | undefined;
 };
-export declare const kDirectContent: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
-        [kDirectContent]?: true;
+        directContent?: true;
     }
 }
-export declare function getBindingPropTree(binding: Binding): BindingPropTree | undefined;
+export declare function getBindingPropTree(binding: Binding, bodyAnalyzed?: boolean): BindingPropTree;
+export declare function getSettledPropTree(propTree: BindingPropTree | undefined): BindingPropTree | undefined;
 export declare function getKnownFromPropTree(propTree: BindingPropTree | true, name: string): BindingPropTree | true | undefined;
 export declare function getAllKnownPropNames(propTree: BindingPropTree): string[];
 export declare function hasAllKnownProps(propTree: BindingPropTree): boolean | undefined;

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

@@ -0,0 +1,127 @@
+import { types as t } from "@marko/compiler";
+import { ReservedId } from "../../common/types";
+import * as BindingType from "./constants/binding-type";
+import { type Opt, type SortedMany, type SortedOpt, Sorted } from "./optional";
+import { type AssignedBindingExtra, type Read, type ReferencedExtra } from "./references";
+import { type Section } from "./sections";
+import { type Sources } from "./sources";
+type BindingType = BindingType.Value;
+export { BindingType };
+export interface Binding {
+    /** Its scope accessor id, allocated per section once references finalize. */
+    id: number;
+    /** Creation order, never renumbered: the order `bindingUtil` sorts by. */
+    uid: number;
+    name: string;
+    originalName: string | undefined;
+    type: BindingType;
+    loc: t.SourceLocation | null;
+    section: Section;
+    closureSections: SortedOpt<Section>;
+    /** The id its closure accessors take, past its section's and ancestors' ids. */
+    closureId: number | undefined;
+    /** The identifier of each emitted assignment to it (set in finalize). */
+    assignments: Opt<AssignedBindingExtra>;
+    sources: undefined | Sources;
+    /** The intersection whose work computes it, or the nearest one it derives
+     * from. Set on alias roots only. */
+    intersection: Intersection | undefined;
+    /** 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. */
+    reads: Map<ReferencedExtra, Opt<Read>>;
+    aliases: Set<Binding>;
+    hoists: SortedOpt<Section>;
+    getters: Map<Getter["hoisted"], boolean>;
+    property: string | undefined;
+    propertyAliases: Map<string, Binding>;
+    excludeProperties: SortedOpt<string>;
+    aliasOf: Binding | undefined;
+    /** The value these `<for>` params iterate, by `of` or `in`. */
+    iterates: {
+        expr: t.NodeExtra;
+        type: "of" | "in";
+    } | undefined;
+    restOffset: number | undefined;
+    /** For a tag variable a child's `<return>` writes, the node binding of the
+     * tag rendering that child. */
+    returnedBy: Binding | undefined;
+    /** Scope ids it holds right after its own, up to its highest `ReservedId`:
+     * a controllable `<let>`'s change handler, or a tag's scope offset. */
+    reserveSize: number;
+    scopeAccessor: string | undefined;
+    /** A name declared for this value, or all of it but its `excludeProperties`
+     * (a rest element), even once pruned. */
+    declaredAlias: Binding | undefined;
+    /** The attribute tag `<for>` param a local closure holds in its section. */
+    localOf: Binding | undefined;
+    /** An attribute tag `<for>` param's local closure in each content the loop
+     * creates that reads it. */
+    localClosures: Map<Section, Binding> | undefined;
+    /** Declared by its own name in its own section; an alias only in a pattern
+     * holding a rest or where what it reads from is hidden from a read of it. */
+    declared: boolean;
+    nullable: boolean;
+    /** Settled only once `finalizeReferences` runs at program analyze exit. */
+    pruned: boolean | undefined;
+    /** 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. */
+    hasLazyReads: boolean;
+}
+/** A param of a template or of a tag body, which its caller supplies. */
+export interface ParamBinding extends Binding {
+    type: typeof BindingType.param;
+}
+export type ReferencedBindings = SortedOpt<Binding>;
+export type Intersection = SortedMany<Binding>;
+/** Every member computed from one local source in the same pass, or the
+ * intersection's own render id and the tag whose scope offset it renders after. */
+export type IntersectionMeta = {
+    source: Binding;
+    id?: undefined;
+    returnedBy?: undefined;
+} | {
+    source: undefined;
+    id: number;
+    returnedBy: Binding | undefined;
+};
+export interface Getter {
+    hoisted: Section | false;
+    invoked: boolean;
+}
+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): Binding;
+export declare function reserveId(binding: Binding, offset: ReservedId): void;
+export declare function getOrCreatePropertyAlias(binding: Binding, property: string): Binding;
+export declare function getPropertyAlias(binding: Binding | undefined, properties: Opt<string>): Binding | undefined;
+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 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 getNearestDeclared(binding: Binding): Binding | undefined;
+export declare function isDirectAlias(binding: Binding): boolean;
+export declare function getDebugScopeAccess(binding: Binding): {
+    root: Binding;
+    access: string;
+};
+export declare function isTemplateParam(binding: Binding): boolean;
+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 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-literal.d.ts

@@ -1,8 +1,7 @@
 import { types as t } from "@marko/compiler";
-export declare const kRawText: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoPlaceholderExtra {
-        [kRawText]?: true;
+        rawText?: true;
     }
 }
 export declare function bodyToTextLiteral(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;

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

@@ -1,10 +1,10 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "./references";
+import { type Binding } from "./bindings";
+import { type Reasons } from "./reasons";
 import { type Section } from "./sections";
-import { type SerializeReason, type SerializeReasons } from "./serialize-reasons";
-export declare function getBranchSectionAccessor(nodeBinding: Binding): NonNullable<Section["sectionAccessor"]>;
-export declare function initBranchSection(bodySection: Section, upstreamExpression: Section["upstreamExpression"], sectionAccessor: Section["sectionAccessor"]): void;
-export declare function resumeOwnerByMarkerWhenStatic(tagSection: Section, bodySection: Section, nodeBinding: Binding, statefulReasonKey: symbol): void;
-export declare function getBranchResumeArgs(tag: t.NodePath<t.MarkoTag>, tagSection: Section, nodeBinding: Binding, branchReasons: SerializeReasons, statefulReasonKey: symbol, onlyChildParentTagName: string | false | undefined, singleNode: boolean): (t.Expression | undefined)[];
-export declare function getBranchEndArgs(tag: t.NodePath<t.MarkoTag>, tagSection: Section, nodeBinding: Binding, statefulReason: SerializeReason | undefined, onlyChildParentTagName: string | false | undefined, singleNode: boolean | undefined): (t.Expression | undefined)[];
+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 isEndTagWrittenByBranch(nodeBinding: Binding | undefined): boolean;
 export declare function isSingleNodeBranch(bodySection: Section | undefined): boolean;

package/dist/translator/util/constants/binding-type.d.ts

@@ -1,11 +1,10 @@
 export declare const dom = 0;
 declare const let_ = 1;
 export { let_ as let };
-export declare const input = 2;
-export declare const param = 3;
-export declare const local = 4;
-export declare const derived = 5;
-export declare const constant = 6;
-export declare const global = 7;
+export declare const param = 2;
+export declare const local = 3;
+export declare const derived = 4;
+export declare const constant = 5;
+export declare const global = 6;
 type Self = typeof import("./binding-type");
 export type Value = Self[keyof Self];

package/dist/translator/util/constants/slot-kind.d.ts

@@ -0,0 +1,14 @@
+export declare const Value = 0;
+export declare const ChangeHandler = 1;
+export declare const ClosureScopes = 2;
+export declare const ClosureSignalIndex = 3;
+export declare const BranchExpr = 4;
+export declare const ParamGroup = 5;
+export declare const Scope = 6;
+export declare const Owner = 7;
+export declare const ReturnChangeHandler = 8;
+export declare const Branch = 9;
+export declare const Instances = 10;
+type Self = typeof import("./slot-kind");
+export type Value = Self[keyof Self];
+export {};

package/dist/translator/util/constants/structure-kind.d.ts

@@ -1,4 +1,4 @@
-export declare const Visit = "visit";
+export declare const Node = "node";
 export declare const Text = "text";
 export declare const Child = "child";
 export declare const SectionRef = "sectionRef";

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

@@ -10,6 +10,8 @@ declare module "@marko/compiler/dist/types" {
 interface EntryState {
     init: boolean;
     load: 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. */

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

@@ -1,15 +1,16 @@
 import type { types as t } from "@marko/compiler";
+interface Evaluated {
+    confident: boolean;
+    computed: unknown;
+    nullable: boolean;
+    /** Evaluating it has no side effects. */
+    pure: boolean;
+}
+declare const kEvaluated: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
-        confident?: boolean;
-        computed?: unknown;
-        nullable?: boolean;
-        /** Evaluating it has no side effects, so an unread value can go. */
-        pure?: boolean;
+        [kEvaluated]?: Evaluated;
     }
 }
-export default function evaluate<T extends t.Expression>(value: T): T["extra"] & {
-    confident: boolean;
-    nullable: boolean;
-    computed: unknown;
-};
+export default function evaluate(value: t.Expression): Evaluated;
+export {};

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

@@ -0,0 +1,4 @@
+import { type Binding, type ReferencedBindings } from "./bindings";
+export declare function finalizeReferences(): void;
+export declare function getValueInputs(binding: Binding): ReferencedBindings;
+export declare function hasEmittedAssignment(binding: Binding): boolean;

package/dist/translator/util/for-selector.d.ts

@@ -1,4 +1,4 @@
-import { type Binding } from "./references";
+import { type Binding } from "./bindings";
 import { type Section } from "./sections";
 export declare function getForSelectorKey(bodySection: Section, closure: Binding): Binding | undefined;
 export declare function isForSelectorValue(binding: Binding): boolean;

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

@@ -1,6 +1,13 @@
 import { types as t } from "@marko/compiler";
 import type { Section } from "./sections";
+declare const kUidCounts: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        [kUidCounts]?: Map<string, number>;
+    }
+}
 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 {};

package/dist/translator/util/get-declared-binding-expression.d.ts

@@ -1,3 +1,3 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "./references";
-export declare function getDeclaredBindingExpression(binding: Binding): t.Identifier | t.MemberExpression | t.OptionalMemberExpression;
+import { type Binding } from "./bindings";
+export declare function getDeclaredBindingExpression(binding: Binding, inPlace?: boolean): t.Identifier | t.MemberExpression | t.OptionalMemberExpression;

package/dist/translator/util/is-core-tag.d.ts

@@ -8,6 +8,3 @@ export declare function isCoreTagName(tag: t.NodePath, name: string): tag is t.N
 export declare function isConditionTag(tag: t.NodePath): tag is t.NodePath<t.MarkoTag & {
     name: t.StringLiteral;
 }>;
-export declare function isControlFlowTag(tag: t.NodePath): tag is t.NodePath<t.MarkoTag & {
-    name: t.StringLiteral;
-}>;

package/dist/translator/util/is-only-child-in-parent.d.ts

@@ -1,14 +1,9 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "./references";
-import type { Section } from "./sections";
 declare const kOnlyChildInParent: unique symbol;
-declare const kNodeRef: unique symbol;
 declare module "@marko/compiler/dist/types" {
-    interface NodeExtra {
+    interface MarkoTagExtra {
         [kOnlyChildInParent]?: false | string;
-        [kNodeRef]?: Binding;
     }
 }
-export declare function getOnlyChildParentTagName(tag: t.NodePath<t.MarkoTag>, branchSize?: number): string | false;
-export declare function getOptimizedOnlyChildNodeBinding(tag: t.NodePath<t.MarkoTag>, section: Section, branchSize?: number): Binding;
+export declare function getOnlyChildParentTagName(tag: t.NodePath<t.MarkoTag>): string | false;
 export {};

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

@@ -1,21 +1,22 @@
 import { types as t } from "@marko/compiler";
 import { type BindingPropTree } from "./binding-prop-tree";
-import { type Binding, type KnownExprs } from "./references";
+import { type Binding } from "./bindings";
+import { type KnownExprs } from "./references";
 import { type Section } from "./sections";
 declare const kContentSection: unique symbol;
-declare const kChildScopeBinding: unique symbol;
-declare const kChildOffsetScopeBinding: unique symbol;
+declare const kPropTree: unique symbol;
 declare const kKnownExprs: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
         [kContentSection]?: Section;
-        [kChildScopeBinding]?: Binding;
-        [kChildOffsetScopeBinding]?: Binding;
+        /** The child's params tree the call site was analyzed against. */
+        [kPropTree]?: BindingPropTree;
         [kKnownExprs]?: KnownExprs;
     }
 }
 export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, contentSection: Section, propTree: BindingPropTree | undefined): void;
-export declare function knownTagTranslateHTML(tag: t.NodePath<t.MarkoTag>, tagIdentifier: t.Expression, contentSection: Section, propTree: BindingPropTree | undefined): void;
-export declare function knownTagTranslateDOM(tag: t.NodePath<t.MarkoTag>, propTree: BindingPropTree | undefined, getBindingIdentifier: (binding: Binding, preferredName?: string, directContent?: boolean) => t.Identifier, callSetup: ((section: Section, childBinding: Binding) => void) | undefined): 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 callsOtherTemplateSetup(section: Section): boolean;
 export {};

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

@@ -0,0 +1,3 @@
+import { types as t } from "@marko/compiler";
+import { type Signal } from "./signals";
+export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression, signal?: Signal): t.Expression | undefined;

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

@@ -0,0 +1,32 @@
+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 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 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 & {
+    state: undefined;
+    always: undefined;
+};
+export declare function isUnconditionalReason(reason: undefined | Reason): reason is Reason;
+export declare function isStateReason(reason: undefined | Reason): reason is Sources;
+export declare function getSourcesForExpr(expr: t.NodeExtra): Sources | undefined;
+export declare function getSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): Sources | undefined;
+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 declare function applyReasonExprs(section: Section): void;
+export declare function finalizeReason(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;