marko 6.0.162 → 6.0.164

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

@@ -4,4 +4,3 @@ 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 getSharedUidIdentifier(name: string): t.Identifier;

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

@@ -1,9 +1 @@
-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/get-root.d.ts

@@ -2,7 +2,7 @@ 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 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.FunctionExpression | t.ObjectMember> | undefined;
-export declare function getFnParent(path: t.NodePath<t.Node>): t.NodePath<t.ArrowFunctionExpression | t.FunctionExpression | t.ObjectMember> | undefined;
+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;

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

@@ -6,7 +6,6 @@ export interface AttrTagMeta {
     group: AttrTagNames;
 }
 export type AttrTagLookup = Record<string, AttrTagMeta>;
-export type AttrTagGroup = AttrTagLookup[string]["group"];
 type AttrTagNames = string[];
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
@@ -15,5 +14,6 @@ declare module "@marko/compiler/dist/types" {
     }
 }
 export declare function getAttrTagIdentifier(meta: AttrTagLookup[string]): t.Identifier;
+export declare function getAttrTagPaths(tag: t.NodePath<t.MarkoTag>): ReturnType<typeof tag.get<"attributeTags">>;
 export declare function analyzeAttributeTags(tag: t.NodePath<t.MarkoTag>): AttrTagLookup | undefined;
 export {};

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

@@ -138,7 +138,6 @@ export declare function getDebugScopeAccess(binding: Binding): {
 export declare function getDebugName(binding: Binding): string;
 export declare function getDebugNames(refs: ReferencedBindings): string;
 export declare function getDebugNamesAsIdentifier(refs: ReferencedBindings): string;
-export declare function getDebugNameAsIdentifier(binding: Binding): string;
 export declare function getSectionInstancesAccessor(section: Section): string;
 export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral | t.NumericLiteral | undefined;
 export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression, signal?: Signal): t.Expression | undefined;
@@ -146,7 +145,6 @@ export declare function hasNonConstantPropertyAlias(ref: Binding): boolean;
 export declare function pruneBinding(binding: Binding): boolean;
 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 getObjectPropertyKeyString(expr: t.ObjectProperty | t.ObjectMethod): string | undefined;
 export interface ReferencedExtra extends t.NodeExtra {
     section: Section;
 }

package/dist/translator/util/resolve-relative-to-entry.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export declare function resolveRelativeToEntry(entryFile: t.BabelFile, file: t.BabelFile, req: string): string;

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

@@ -1,12 +1,13 @@
 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 { _attr, _attr_class, _attr_style, _escape, _escape_comment, _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.MemberExpression;
 export declare function callRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers, ...args: Array<Parameters<typeof t.callExpression>[1][number] | Falsy>): t.CallExpression;
 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/scope-read.d.ts

@@ -1,6 +1,5 @@
 import { types as t } from "@marko/compiler";
-import { type Binding, type ReferencedBindings } from "./references";
+import { type Binding } from "./references";
 import type { Section } from "./sections";
-export declare function createScopeReadPattern(section: Section, referencedBindings: ReferencedBindings): t.ObjectPattern;
 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/sections.d.ts

@@ -72,7 +72,6 @@ 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;
 export declare const getBranchRendererArgs: (section: Section) => [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined], setBranchRendererArgs: (section: Section, value: [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined]) => void;
-export declare const getScopeIdentifier: (section: Section, ignoreDefault?: boolean) => t.Identifier;
 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;

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

@@ -5,9 +5,6 @@ import { type Binding, type InputBinding, type ParamBinding, type ReferencedBind
 import type { Section } from "./sections";
 export type SerializeReasons = true | [Sources, ...Sources[]];
 export type SerializeReason = true | Sources;
-export type SerializeKey = symbol & {
-    __serialize_key__: 1;
-};
 export declare function isSameReason(a: SerializeReason | undefined, b: SerializeReason | undefined): boolean;
 export declare function isForceSerialized(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): boolean;
 export declare function addSerializeReason(section: Section, reason: undefined | false | SerializeReason, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;

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

@@ -39,12 +39,10 @@ export declare function initValue(binding: Binding, isLet?: boolean): Signal;
 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 subscribe(references: ReferencedBindings, subscriber: Signal): void;
 export declare function replaceNullishAndEmptyFunctionsWith0(args: (t.Expression | undefined | false)[]): t.Expression[];
 export declare function addStatement(type: "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[], usedReferences?: ReferencedBindings[] | false, 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 getRegisterUID(section: Section, name: string): string;
 export declare function writeSignals(section: Section): Set<Signal>;
 export declare function writeRegisteredFns(): void;
 export declare function addHTMLEffectCall(section: Section, referencedBindings?: ReferencedBindings): void;

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

@@ -1,3 +1,3 @@
 import type { Section } from "./sections";
-export declare const createProgramState: <T>(init: () => T) => readonly [() => T, (value: T) => void];
+export declare function createProgramState<T>(init: () => T): readonly [() => T, (value: T) => void];
 export declare function createSectionState<T = unknown>(key: string, init?: ((section: Section) => T) | (() => T)): readonly [(section: Section) => T, (section: Section, value: T) => void];

package/dist/translator/visitors/program/index.d.ts

@@ -1,19 +1,8 @@
 import { types as t } from "@marko/compiler";
 import { type BindingPropTree } from "../../util/binding-prop-tree";
-import { type Sources } from "../../util/references";
 import { preAnalyze } from "./pre-analyze";
-export type ParamSerializeReason = NonNullable<Sources["param"]>;
-export interface ParamSerializeReasonGroup {
-    id: symbol;
-    reason: ParamSerializeReason;
-}
-export type ParamSerializeReasonGroups = [
-    ParamSerializeReasonGroup,
-    ...ParamSerializeReasonGroup[]
-];
 export declare let scopeIdentifier: t.Identifier;
 export declare function isScopeIdentifier(node: t.Node): node is t.Identifier;
-export type TemplateExports = BindingPropTree["props"];
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         domExports?: {

package/dist/translator/visitors/program/pre-analyze.d.ts

@@ -1,3 +1,2 @@
 import { types as t } from "@marko/compiler";
 export declare function preAnalyze(program: t.NodePath<t.Program>): void;
-export declare function getAssignmentInsertions(node: t.Node, insertions?: t.MarkoTag[] | undefined): t.MarkoTag[] | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.162",
+  "version": "6.0.164",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",