marko 6.3.56 → 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/references.d.ts

@@ -201,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;
@@ -31,7 +31,7 @@ export declare function mergeSerializeReasons(a: SerializeReason, b: undefined |
 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 hasOwnResumeReason(section: Section): 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/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.56",
+  "version": "6.4.0",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,13 +51,13 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.9",
+    "@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.56",
+    "@marko/runtime-tags": "npm:marko@6.4.0",
     "marko": "5.39.44"
   },
   "engines": {

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;