marko 6.3.55 → 6.4.0

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

@@ -1,6 +1,8 @@
+import { types as t } from "@marko/compiler";
 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/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/generate-uid.d.ts

@@ -1,5 +1,10 @@
 import { types as t } from "@marko/compiler";
 import type { Section } from "./sections";
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        uidCounts?: 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;

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

@@ -28,19 +28,17 @@ export declare function size<T>(data: Opt<T>): number;
 export declare function filter<T>(data: Opt<T>, cb: (item: T) => boolean): Opt<T>;
 export declare function forEach<T>(data: Opt<T>, cb: (item: T, index: number) => void): void;
 export declare function fromIter<T>(data: Iterable<T>): T | Many<T> | undefined;
-export declare function toIter<T>(data: Opt<T>): Iterable<T>;
-export declare function includes<T>(data: Opt<T>, item: T): boolean;
 export declare function find<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): Opt<T>;
 export declare function some<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): boolean;
 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 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;
 export declare function findSorted<T>(compare: Compare<T>, data: T[], item: T): T | undefined;
 export declare function findIndexSorted<T>(compare: Compare<T>, data: T[], item: T): number;
 export declare function addSorted<T, U extends T[]>(compare: Compare<T>, data: U, item: T): U;
-export declare function addUnique<T>(data: Opt<T>, item: T): OneMany<T>;
 export declare function at<T>(data: Opt<T>, index: number): T | undefined;
 export declare function first<T>(data: OneMany<T>): T;
 export declare function rest<T>(data: OneMany<T>): Opt<T>;

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

@@ -36,6 +36,7 @@ export interface Binding {
     sources: undefined | Sources;
     /** The intersection whose work computes it, or the nearest one upstream. Set on alias roots only. */
     upstreamIntersection: Intersection | undefined;
+    /** Complete only once `finalizeReferences` runs at program analyze exit. */
     reads: Set<ReferencedExtra>;
     aliases: Set<Binding>;
     hoists: SortedOpt<Section>;
@@ -64,6 +65,7 @@ export interface Binding {
     localClosures: Map<Section, Binding> | undefined;
     declared: boolean;
     nullable: boolean;
+    /** Settled only once `finalizeReferences` runs at program analyze exit. */
     pruned: boolean | undefined;
     exposed: boolean;
     forcePersist: boolean;
@@ -163,6 +165,7 @@ declare module "@marko/compiler/dist/types" {
 export declare function createBinding(name: string, type: Binding["type"], refSection: Section, upstreamAlias?: Binding["upstreamAlias"], property?: string, excludeProperties?: SortedOpt<string>, loc?: t.SourceLocation | null, refDeclared?: boolean): Binding;
 export declare function getOrCreatePropertyAlias(binding: Binding, property: string): Binding;
 export declare function getPropertyAlias(binding: Binding | undefined, properties: Opt<string>): Binding | undefined;
+export declare function isTagVarRead(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, upstreamAlias?: Binding["upstreamAlias"]): Binding | undefined;
 export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType): Binding | undefined;
@@ -198,16 +201,17 @@ export declare function getExpressionReads(exprExtra: ReferencedExtra): Opt<Read
 export declare function addRead(exprExtra: ReferencedExtra, extra: t.NodeExtra, binding: Binding, section: Section, getter: Getter | undefined): Read;
 export declare function dropNodes(node: t.Node | t.Node[]): void;
 export declare function untrackNode(node: t.Node): void;
+export declare function dropContent(body: t.MarkoTagBody): void;
 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 someUpstream<A>(binding: Binding | undefined, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
 export declare function isDirectAlias(binding: Binding): boolean;
-export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[], getAttrTagNodes?: (attrTag: t.MarkoTag) => t.Node[]): t.Node[];
+export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[], collectAttrTag?: (attrTag: t.MarkoTag) => void): t.Node[];
 export declare function getScopeAccessorLiteral(binding: Binding, encoded?: boolean, includeId?: boolean): t.NumericLiteral | t.StringLiteral;
 export declare function getScopeAccessor(binding: Binding, encoded?: boolean, includeId?: boolean): string;
 export declare function getLocalsScopeAccessor(binding: Binding): string;
 export declare function getPrefixedScopeAccessor(binding: Binding, prefix: AccessorPrefix): string;
-export declare function getClosureAccessorId(binding: Binding): number;
+export declare function getClosureAccessorLiteral(binding: Binding): t.NumericLiteral | t.StringLiteral;
 export declare function getDebugScopeAccess(binding: Binding): {
     root: Binding;
     access: string;

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

@@ -1,18 +1,18 @@
 import { types as t } from "@marko/compiler";
 import type { Falsy } from "../../common/types";
-import { _attr, _attr_class, _attr_style, _escape, _escape_comment, _escape_script, _escape_style, _unescaped } from "../../html";
+import { _attr, _attr_class, _attr_style, _escape, _escape_script, _escape_style, _unescaped } from "../../html";
 export type DOMRuntimeHelpers = keyof typeof import("../../dom");
 export type HTMLRuntimeHelpers = keyof typeof import("../../html");
 export declare function importRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers): t.Identifier;
 export declare function registerRuntimeValue(id: string, value: t.Expression): t.AssignmentExpression;
 export declare function callRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers, ...args: Array<Parameters<typeof t.callExpression>[1][number] | Falsy>): t.CallExpression;
 export declare function dynamicImport(request: string, ...handlers: Array<t.Expression | Falsy>): t.CallExpression;
-export declare const domRuntimeFeatures: readonly ["catch", "controllable", "controllable-input", "controllable-open", "controllable-select", "controllable-textarea", "dynamic-tag-script", "dynamic-tag-var", "placeholder"];
+export declare const domRuntimeFeatures: readonly ["catch", "controllable", "controllable-input", "controllable-open", "controllable-select", "controllable-textarea", "dynamic-tag-script", "dynamic-tag-var", "lazy", "placeholder"];
 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;
-    _escape_comment: typeof _escape_comment;
     _unescaped: typeof _unescaped;
     _attr: typeof _attr;
     _attr_class: typeof _attr_class;

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

@@ -63,7 +63,6 @@ export interface Section {
     referencedHoists: ReferencedBindings;
     bindings: ReferencedBindings;
     hoisted: ReferencedBindings;
-    hoistedTo: ReferencedBindings;
     serializeReason: undefined | SerializeReason;
     serializeReasons: Map<symbol, SerializeReason>;
     /** Reasons any of the section's dom nodes resumes, as the analyzed reasons
@@ -80,7 +79,8 @@ export interface Section {
     returnSerializeReason: SerializeReason | undefined;
     isHoistThrough: true | undefined;
     upstreamExpression: t.NodeExtra | undefined;
-    /** For a `<define>` body, the sections whose direct calls render it. */
+    /** For a `<define>` body or a template rendering itself, the sections whose
+     * direct calls render it. */
     callSections: SortedOpt<Section>;
     /** The content's rendering tag (its extra), and each child binding the
      * content feeds, at `properties`. */
@@ -90,11 +90,16 @@ export interface Section {
         properties: Opt<string>;
         exprs: KnownExprs | undefined;
     } | undefined;
+    /** Content a known child never reads, which no output renders. */
+    pruned: boolean;
     hasAbortSignal: boolean;
     /** Count of distinct `$signal` expression roots; analyze allocates each
      * root's `abortId` from this so translates read, never re-derive. */
     abortSignalExprs: number;
     readsOwner: boolean;
+    /** Whether analysis found work keyed by setup in the section, or in a
+     * `<define>` body or template it calls in place. */
+    hasSetupWork: boolean;
     isBranch: boolean;
     content: null | {
         startType: ContentType;
@@ -116,6 +121,7 @@ export declare const sectionUtil: Sorted<Section>;
 export declare function startSection(path: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
 export declare function getOrCreateSection(path: t.NodePath<any>): Section;
 export declare function getSectionForBody(body: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
+export declare function removePrunedContent(tag: t.NodePath<t.MarkoTag>): void;
 export declare function getSection(path: t.NodePath): Section;
 export declare const getScopeIdIdentifier: (section: Section) => t.Identifier;
 export declare const getSectionParentIsOwner: (section: Section) => boolean, setSectionParentIsOwner: (section: Section, value: boolean) => void;

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

@@ -2,7 +2,7 @@ import { types as t } from "@marko/compiler";
 import { AccessorPrefix, AccessorProp } from "../../common/types";
 import { type Opt, Sorted, type SortedOneMany } from "./optional";
 import { type Binding, type KnownExprs, type ReferencedBindings, type Sources } from "./references";
-import { type Section } from "./sections";
+import { type ParamSerializeReasonGroups, type Section } from "./sections";
 export type SerializeReasons = SortedOneMany<Sources>;
 export declare const sourcesUtil: Sorted<Sources>;
 export type SerializeReason = Sources;
@@ -30,6 +30,8 @@ export declare function mapParamReason(program: Section, reason: Sources, exprs:
 export declare function mergeSerializeReasons(a: SerializeReason, b: undefined | SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: undefined | SerializeReason): SerializeReason | undefined;
+export declare function isOwnResumeReason(reason: SerializeReason | undefined): boolean;
 export declare function applySerializeExprs(section: Section): void;
 export declare function finalizeSerializeReason(section: Section): void;
 export declare function getSerializeReasonsVersion(): number;
+export declare function setParamReasonGroups(section: Section, groups: ParamSerializeReasonGroups): void;

package/dist/translator/util/setup-work.d.ts

@@ -0,0 +1,5 @@
+import type { types as t } from "@marko/compiler";
+import { type Section } from "./sections";
+export declare function addSetupWork(section: Section): void;
+export declare function addSetupExpr(section: Section, node: t.Node | undefined): void;
+export declare function finalizeSetupWork(): void;

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

@@ -12,22 +12,20 @@ export interface Signal {
     referenced?: boolean;
     values: Array<{
         signal: Signal;
-        value: t.Expression;
+        /** None for a signal that runs on the scope alone. */
+        value: t.Expression | undefined;
     }>;
     intersection: Opt<Signal>;
     /** Signals this one forwards into: they must declare first when the
      * forward simplifies to a bare, eagerly evaluated reference. */
     forwards: Opt<Signal>;
-    /** Runs before `render`: registrations (eg `_var`) that an earlier tag's
-     * synchronous `_return` may reach before the registering tag's own setup. */
-    prepare: t.Statement[];
     render: t.Statement[];
     effect: t.Statement[];
     hasHTMLEffect: boolean;
     hasSideEffect: boolean;
     forcePersist: boolean;
     inline: {
-        value: t.Expression;
+        value: t.Expression | undefined;
     } | undefined;
     export: boolean;
     extraArgs: t.Expression[] | undefined;
@@ -55,8 +53,8 @@ export declare function signalHasStatements(signal: Signal): boolean;
 export declare function getSignalFn(signal: Signal): t.Expression;
 export declare function getSignalValueIdentifier(signal: Signal): t.Identifier;
 export declare function replaceNullishAndEmptyFunctionsWith0(args: (t.Expression | undefined | false)[]): t.Expression[];
-export declare function addStatement(type: "prepare" | "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[], isPure?: boolean): void;
-export declare function addValue(targetSection: Section, referencedBindings: ReferencedBindings, signal: Signal, value: t.Expression): void;
+export declare function addStatement(type: "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[], isPure?: boolean): void;
+export declare function addValue(targetSection: Section, referencedBindings: ReferencedBindings, signal: Signal, value?: t.Expression): void;
 export declare function getResumeRegisterId(section: Section, referencedBindings: string | ReferencedBindings, type?: string): string;
 export declare function writeSignals(section: Section): Set<Signal>;
 export declare function writeRegisteredFns(): void;

package/dist/translator/util/translate-attrs.d.ts

@@ -1,8 +1,9 @@
 import { types as t } from "@marko/compiler";
 import { type BindingPropTree } from "./binding-prop-tree";
 import { type AttrTagLookup } from "./nested-attribute-tags";
+import { type SortedOpt } from "./optional";
 type ContentKey = "renderBody" | "content";
-export declare function translateAttrs(tag: t.NodePath<t.MarkoTag>, propTree?: BindingPropTree | true, skip?: Set<string>, statements?: t.Statement[], contentKey?: ContentKey): {
+export declare function translateAttrs(tag: t.NodePath<t.MarkoTag>, propTree?: BindingPropTree | true, skip?: SortedOpt<string>, statements?: t.Statement[], contentKey?: ContentKey): {
     properties: (t.ObjectMethod | t.ObjectProperty | t.SpreadElement)[];
     statements: t.Statement[];
 };

package/dist/translator/visitors/tag/native-tag.d.ts

@@ -33,3 +33,4 @@ export declare function controllableClaimFor(tagName: string | undefined): "_con
  * kind at run time, and a run-time tag name can be any of them. */
 export declare function controllableFeatureFor(tagName: string | undefined): "controllable" | "controllable-input" | "controllable-open" | "controllable-select" | "controllable-textarea" | undefined;
 export declare function enableControllable(feature: DOMRuntimeFeature | undefined): void;
+export declare function isPageElement(tagName: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.3.55",
+  "version": "6.4.0",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,13 +51,13 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.8",
+    "@marko/compiler": "^5.42.10",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.3.55",
+    "@marko/runtime-tags": "npm:marko@6.4.0",
     "marko": "5.39.44"
   },
   "engines": {

package/tags-html.d.ts

@@ -1662,7 +1662,8 @@ declare global {
          */
         type?: AttrMissing | "context" | "toolbar";
       }
-      interface Meta extends HTMLAttributes<HTMLMetaElement> {
+      // The one tag whose `content` is its HTML attribute instead of its body.
+      interface Meta extends Omit<HTMLAttributes<HTMLMetaElement>, "content"> {
         /**
          * Specifies the character encoding for the HTML document.
          * @see https://html.spec.whatwg.org/multipage/semantics.html#attr-meta-charset
@@ -4413,7 +4414,7 @@ declare global {
        * @see Marko.Body
        */
       content?:
-        | AttrString
+        | AttrMissing
         | Marko.Body<[], void>
         | Marko.Template<Record<any, never>, void>;
 
@@ -4466,7 +4467,7 @@ declare global {
        * @see Marko.Body
        */
       content?:
-        | AttrString
+        | AttrMissing
         | Marko.Body<[], void>
         | Marko.Template<Record<any, never>, void>;
 

package/dist/translator/util/setup-statements.d.ts

@@ -1,5 +0,0 @@
-import type { types as t } from "@marko/compiler";
-import type { Section } from "./sections";
-export declare function addSetupStatement(section: Section): void;
-export declare function addSetupExpr(section: Section, node: t.Node | undefined): void;
-export declare function sectionHasSetupStatements(section: Section): boolean;