marko 6.0.0-next.3.83 → 6.0.0-next.3.84

package/dist/translator/util/get-accessor-char.d.ts

@@ -1,4 +1,3 @@
-import { AccessorPrefix as ProductionAccessorPrefix, AccessorProp as ProductionAccessorProp } from "../../common/accessor";
 import { AccessorPrefix as DebugAccessorPrefix, AccessorProp as DebugAccessorProp } from "../../common/accessor.debug";
-export declare function getAccessorPrefix(): typeof DebugAccessorPrefix | typeof ProductionAccessorPrefix;
-export declare function getAccessorProp(): typeof DebugAccessorProp | typeof ProductionAccessorProp;
+export declare function getAccessorPrefix(): typeof DebugAccessorPrefix;
+export declare function getAccessorProp(): typeof DebugAccessorProp;

package/dist/translator/util/get-compile-stage.d.ts

@@ -0,0 +1,9 @@
+export declare enum CompileStage {
+    parse = "parse",
+    migrate = "migrate",
+    transform = "transform",
+    analyze = "analyze",
+    translate = "translate"
+}
+export declare function getCompileStage(): CompileStage;
+export declare function isTranslate(): boolean;

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

@@ -10,5 +10,5 @@ declare module "@marko/compiler/dist/types" {
     }
 }
 export declare function isOnlyChildInParent(tag: t.NodePath<t.MarkoTag>, branchSize?: number): boolean;
-export declare function getOptimizedOnlyChildNodeRef(tag: t.NodePath<t.MarkoTag>, section: Section, branchSize?: number): Binding;
+export declare function getOptimizedOnlyChildNodeBinding(tag: t.NodePath<t.MarkoTag>, section: Section, branchSize?: number): Binding;
 export {};

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

@@ -5,17 +5,18 @@ export type Compare<T> = (a: T, b: T) => number;
 export declare class Sorted<T> {
     compare: Compare<T>;
     constructor(compare: Compare<T>);
-    add(data: Opt<T>, item: T): OneMany<T>;
-    union(a: Opt<T>, b: Opt<T>): Opt<T>;
-    find(data: Opt<T>, item: T): T | undefined;
-    findIndex(data: Opt<T>, item: T): number;
-    isSuperset(superset: Opt<T>, subset: Opt<T>): boolean;
+    add<U extends T>(data: Opt<U>, item: U): OneMany<U>;
+    union<U extends T>(a: Opt<U>, b: Opt<U>): Opt<U>;
+    find<U extends T>(data: Opt<U>, item: U): U | undefined;
+    findIndex<U extends T>(data: Opt<U>, item: U): number;
+    isSuperset<U extends T>(superset: Opt<U>, subset: Opt<U>): boolean;
 }
 export declare function push<T>(data: Opt<T>, item: T): Opt<T>;
 export declare function concat<T>(a: Opt<T>, b: Opt<T>): Opt<T>;
 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 find<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): Opt<T>;
 export declare function map<T, R>(data: Opt<T>, cb: (item: T, index: number) => R): R[];
 export declare function findSorted<T>(compare: Compare<T>, data: T[], item: T): T | undefined;

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

@@ -20,8 +20,8 @@ export interface Binding {
     loc: t.SourceLocation | null;
     section: Section;
     closureSections: Opt<Section>;
-    serialize: boolean;
     sources: Opt<Binding>;
+    serializeSources: Opt<InputBinding> | true;
     aliases: Set<Binding>;
     hoists: Map<Section, Binding>;
     property: string | undefined;
@@ -35,6 +35,9 @@ export interface Binding {
     declared: boolean;
     nullable: boolean;
 }
+export interface InputBinding extends Binding {
+    type: BindingType.input;
+}
 export type ReferencedBindings = Opt<Binding>;
 export type Intersection = Many<Binding>;
 declare module "@marko/compiler/dist/types" {

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

@@ -1,6 +1,6 @@
 import { types as t } from "@marko/compiler";
-import { Sorted } from "./optional";
-import type { Binding, ReferencedBindings } from "./references";
+import { type OneMany, Sorted } from "./optional";
+import type { Binding, InputBinding, ReferencedBindings } from "./references";
 export declare enum ContentType {
     Comment = 0,
     Dynamic = 1,
@@ -23,6 +23,7 @@ export interface Section {
     referencedHoists: ReferencedBindings;
     bindings: ReferencedBindings;
     hoisted: ReferencedBindings;
+    serializeReasons: Map<symbol, true | OneMany<InputBinding>>;
     isHoistThrough: true | undefined;
     assignments: ReferencedBindings;
     upstreamExpression: t.NodeExtra | undefined;
@@ -44,6 +45,7 @@ declare module "@marko/compiler/dist/types" {
         section?: Section;
     }
 }
+export declare const kBranchSerializeReason: unique symbol;
 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;
@@ -57,10 +59,11 @@ export declare function forEachSection(fn: (section: Section) => void): void;
 export declare function forEachSectionReverse(fn: (section: Section) => void): void;
 export declare function getNodeContentType(path: t.NodePath<t.Statement>, extraMember: "startType" | "endType", contentInfo?: Section["content"]): ContentType | null;
 export declare const isSerializedSection: (section: Section) => boolean;
-export declare function isSectionWithHoists(section: Section): true | undefined;
+export declare function isSectionWithHoists(section: Section): boolean;
 export declare function isImmediateOwner(section: Section, binding: Binding): boolean;
 export declare function isDirectClosure(section: Section, closure: Binding): boolean;
 export declare function isDynamicClosure(section: Section, closure: Binding): boolean;
+export declare function getDynamicClosureIndex(closure: Binding, closureSection: Section): number;
 export declare function getDirectClosures(section: Section): import("./optional").Opt<Binding>;
 export declare function isSameOrChildSection(section: Section, other: Section): boolean;
 export declare function getCommonSection(section: Section, other: Section): Section;

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

@@ -0,0 +1,22 @@
+import { types as t } from "@marko/compiler";
+import { AccessorPrefix, AccessorProp } from "../../common/types";
+import { type Opt } from "./optional";
+import { type Binding, type InputBinding, type ReferencedBindings } from "./references";
+import type { Section } from "./sections";
+export declare function forcePropSerialize(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol): void;
+export declare function forceBindingSerialize(section: Section, binding: Binding, prefix?: AccessorPrefix): void;
+export declare function isPropForceSerialized(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol): boolean;
+export declare function isBindingForceSerialized(section: Section, binding: Binding, prefix?: AccessorPrefix): boolean;
+export declare function addPropSerializeReasonExpr(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol, expr: undefined | boolean | Opt<t.NodeExtra>): void;
+export declare function addBindingSerializeReasonExpr(section: Section, binding: Binding, expr: undefined | boolean | Opt<t.NodeExtra>, prefix?: AccessorPrefix): void;
+export declare function addPropSerializeReasonRef(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol, ref: undefined | boolean | ReferencedBindings): void;
+export declare function addBindingSerializeReasonRef(section: Section, binding: Binding, ref: undefined | boolean | ReferencedBindings, prefix?: AccessorPrefix): void;
+export declare function addPropSerializeReason(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol, reason: boolean | Opt<InputBinding>): void;
+export declare function addBindingSerializeReason(section: Section, binding: Binding, reason: boolean | Opt<InputBinding>, prefix?: AccessorPrefix): void;
+export declare function getPropSerializeReason(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol): true | import("./optional").OneMany<InputBinding> | undefined;
+export declare function getBindingSerializeReason(section: Section, binding: Binding, prefix?: AccessorPrefix): true | import("./optional").OneMany<InputBinding> | undefined;
+export declare function consumeSerializeReasonExprs(section: Section): Map<symbol, Opt<t.NodeExtra>> | undefined;
+export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): true | Opt<InputBinding>;
+export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra>): true | Opt<InputBinding>;
+export declare function getSerializeSourcesForRef(ref: ReferencedBindings): true | Opt<InputBinding>;
+export declare function mergeSerializeReasons<T extends true | Opt<InputBinding>>(a: T, b: T): T;

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

@@ -1,4 +1,5 @@
 import { types as t } from "@marko/compiler";
+import type { AccessorPrefix, AccessorProp } from "../../common/types";
 import { type Opt } from "./optional";
 import { type Binding, type ReferencedBindings } from "./references";
 import { type Section } from "./sections";
@@ -34,7 +35,9 @@ export type Signal = {
 type closureSignalBuilder = (closure: Binding, render: t.Expression) => t.Expression;
 export declare function setClosureSignalBuilder(tag: t.NodePath<t.MarkoTag>, builder: closureSignalBuilder): void;
 export declare function serializeSectionIfNeeded(section: Section, reason: undefined | boolean | Opt<Binding>): void;
-export declare function setSerializedProperty(section: Section, key: string, expression: t.Expression, reason: undefined | boolean | Opt<Binding>): void;
+export declare function setBindingSerializedValue(section: Section, binding: Binding, expression: t.Expression, prefix?: AccessorPrefix): void;
+export declare function setPropSerializedValue(section: Section, extra: t.NodeExtra, prop: AccessorProp, expression: t.Expression): void;
+export declare function setSerializedValue(section: Section, key: string, expression: t.Expression): void;
 export declare const getHTMLSectionStatements: (section: Section) => t.Statement[];
 export declare function getHoistFunctionIdentifier(hoistedBinding: Binding): t.Identifier;
 export declare function getSignal(section: Section, referencedBindings: ReferencedBindings, name?: string): Signal;

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

@@ -2,12 +2,10 @@ import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
 declare const kChildScopeBinding: unique symbol;
 declare const kChildOffsetScopeBinding: unique symbol;
-declare const kChildAttrExprs: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
         [kChildScopeBinding]?: Binding;
         [kChildOffsetScopeBinding]?: Binding;
-        [kChildAttrExprs]?: Set<t.NodeExtra>;
     }
 }
 declare const _default: {

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

@@ -1,12 +1,12 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
 export declare const kNativeTagBinding: unique symbol;
-export declare const kSerializeMarker: unique symbol;
+export declare const kSkipMark: unique symbol;
 declare const kGetterId: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
         [kNativeTagBinding]?: Binding;
-        [kSerializeMarker]?: boolean;
+        [kSkipMark]?: true;
         [kGetterId]?: string;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.0-next.3.83",
+  "version": "6.0.0-next.3.84",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",

package/dist/translator/util/dynamic-sources.d.ts

@@ -1,17 +0,0 @@
-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 getDynamicSourcesForBinding(binding: Binding): true | import("./optional").OneMany<Binding> | undefined;
-export declare function getDynamicSourcesForExtra(extra: t.NodeExtra): true | Binding | import("./optional").Many<Binding> | undefined;
-export declare function getDynamicSourcesForExtras(extras: Iterable<t.NodeExtra>): true | Opt<Binding>;
-export declare function getDynamicSourcesForSection(section: Section): {
-    referenced: true | Binding | import("./optional").Many<Binding> | undefined;
-    closures: true | Binding | import("./optional").Many<Binding> | undefined;
-    all: true | Opt<Binding>;
-} | undefined;
-export declare function getDynamicSourcesForSections(sections: (Section | undefined)[]): {
-    referenced: true | Binding | import("./optional").Many<Binding> | undefined;
-    closures: true | Binding | import("./optional").Many<Binding> | undefined;
-    all: true | Opt<Binding>;
-} | undefined;