@zeus-js/compiler-shared 0.1.0-beta.9

package/dist/compiler-shared.cjs.js

@@ -0,0 +1,216 @@
+/**
+* compiler-shared v0.1.0-beta.9
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region packages/core/compiler-shared/src/semanticBuilders.ts
+let nextId = 0;
+function id() {
+	return nextId++;
+}
+function ref(name) {
+	return { name };
+}
+function expressionIR(code, span) {
+	return {
+		kind: "Expression",
+		code,
+		span
+	};
+}
+function identifierIR(name, span) {
+	return {
+		kind: "Identifier",
+		name,
+		span
+	};
+}
+function elementIR(input) {
+	var _input$attrs, _input$children;
+	return {
+		id: id(),
+		kind: "Element",
+		ref: input.ref,
+		tagName: input.tagName,
+		attrs: (_input$attrs = input.attrs) !== null && _input$attrs !== void 0 ? _input$attrs : [],
+		children: (_input$children = input.children) !== null && _input$children !== void 0 ? _input$children : [],
+		flags: {
+			isSVG: false,
+			isVoid: false,
+			isCustomElement: input.tagName.includes("-"),
+			...input.flags
+		}
+	};
+}
+function textIR(value) {
+	return {
+		id: id(),
+		kind: "Text",
+		value
+	};
+}
+function dynamicTextIR(expr, nodeRef, once = false) {
+	return {
+		id: id(),
+		kind: "DynamicText",
+		expr,
+		ref: nodeRef,
+		once
+	};
+}
+function fragmentIR(children) {
+	return {
+		id: id(),
+		kind: "Fragment",
+		children
+	};
+}
+function staticAttrIR(name, value) {
+	return {
+		id: id(),
+		kind: "StaticAttribute",
+		name,
+		value
+	};
+}
+function attrBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "AttrBinding",
+		name,
+		expr
+	};
+}
+function propBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "PropBinding",
+		name,
+		expr
+	};
+}
+function eventBindingIR(eventName, handler) {
+	return {
+		id: id(),
+		kind: "EventBinding",
+		eventName,
+		handler
+	};
+}
+function refBindingIR(expr) {
+	return {
+		id: id(),
+		kind: "RefBinding",
+		expr
+	};
+}
+function componentIR(input) {
+	return {
+		id: id(),
+		kind: "Component",
+		ref: input.ref,
+		callee: input.callee,
+		props: input.props
+	};
+}
+function showIR(input) {
+	return {
+		id: id(),
+		kind: "Show",
+		ref: input.ref,
+		when: input.when,
+		children: input.children,
+		fallback: input.fallback
+	};
+}
+function forIR(input) {
+	return {
+		id: id(),
+		kind: "For",
+		ref: input.ref,
+		each: input.each,
+		by: input.by,
+		item: input.item,
+		index: input.index,
+		body: input.body
+	};
+}
+function hostIR(input) {
+	return {
+		id: id(),
+		kind: "Host",
+		attrs: input.attrs,
+		child: input.child
+	};
+}
+function slotIR(input) {
+	var _input$fallback;
+	return {
+		id: id(),
+		kind: "Slot",
+		ref: input.ref,
+		name: input.name,
+		fallback: (_input$fallback = input.fallback) !== null && _input$fallback !== void 0 ? _input$fallback : []
+	};
+}
+//#endregion
+//#region packages/core/compiler-shared/src/visit.ts
+function visitIR(node, visitor, parent) {
+	var _visitor$enter, _visitor$leave;
+	(_visitor$enter = visitor.enter) === null || _visitor$enter === void 0 || _visitor$enter.call(visitor, node, parent);
+	for (const child of getIRChildren(node)) visitIR(child, visitor, node);
+	(_visitor$leave = visitor.leave) === null || _visitor$leave === void 0 || _visitor$leave.call(visitor, node, parent);
+}
+function getIRChildren(node) {
+	switch (node.kind) {
+		case "Element":
+		case "Fragment": return node.children;
+		case "Component": return node.props.flatMap((prop) => Array.isArray(prop.value) ? prop.value : []);
+		case "Show": return [...node.children, ...Array.isArray(node.fallback) ? node.fallback : []];
+		case "For": return node.body;
+		case "Slot": return node.fallback;
+		case "Host": return node.child ? [node.child] : [];
+		case "Text":
+		case "DynamicText": return [];
+	}
+}
+function getComponentChildren(node) {
+	const prop = node.props.find((prop) => prop.name === "children");
+	return prop && Array.isArray(prop.value) ? prop.value : [];
+}
+//#endregion
+//#region packages/core/compiler-shared/src/assert.ts
+function assertElementIR(node) {
+	if (node.kind !== "Element") throw new Error(`Expected Element IR, received ${node.kind}.`);
+}
+function assertNeverIR(node) {
+	throw new Error(`Unhandled IR node ${node.kind}.`);
+}
+//#endregion
+exports.assertElementIR = assertElementIR;
+exports.assertNeverIR = assertNeverIR;
+exports.attrBindingIR = attrBindingIR;
+exports.componentIR = componentIR;
+exports.dynamicTextIR = dynamicTextIR;
+exports.elementIR = elementIR;
+exports.eventBindingIR = eventBindingIR;
+exports.expressionIR = expressionIR;
+exports.forIR = forIR;
+exports.fragmentIR = fragmentIR;
+exports.getComponentChildren = getComponentChildren;
+exports.getIRChildren = getIRChildren;
+exports.hostIR = hostIR;
+exports.id = id;
+exports.identifierIR = identifierIR;
+exports.propBindingIR = propBindingIR;
+exports.ref = ref;
+exports.refBindingIR = refBindingIR;
+exports.showIR = showIR;
+exports.slotIR = slotIR;
+exports.staticAttrIR = staticAttrIR;
+exports.textIR = textIR;
+exports.visitIR = visitIR;

package/dist/compiler-shared.cjs.prod.js

@@ -0,0 +1,216 @@
+/**
+* compiler-shared v0.1.0-beta.9
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region packages/core/compiler-shared/src/semanticBuilders.ts
+let nextId = 0;
+function id() {
+	return nextId++;
+}
+function ref(name) {
+	return { name };
+}
+function expressionIR(code, span) {
+	return {
+		kind: "Expression",
+		code,
+		span
+	};
+}
+function identifierIR(name, span) {
+	return {
+		kind: "Identifier",
+		name,
+		span
+	};
+}
+function elementIR(input) {
+	var _input$attrs, _input$children;
+	return {
+		id: id(),
+		kind: "Element",
+		ref: input.ref,
+		tagName: input.tagName,
+		attrs: (_input$attrs = input.attrs) !== null && _input$attrs !== void 0 ? _input$attrs : [],
+		children: (_input$children = input.children) !== null && _input$children !== void 0 ? _input$children : [],
+		flags: {
+			isSVG: false,
+			isVoid: false,
+			isCustomElement: input.tagName.includes("-"),
+			...input.flags
+		}
+	};
+}
+function textIR(value) {
+	return {
+		id: id(),
+		kind: "Text",
+		value
+	};
+}
+function dynamicTextIR(expr, nodeRef, once = false) {
+	return {
+		id: id(),
+		kind: "DynamicText",
+		expr,
+		ref: nodeRef,
+		once
+	};
+}
+function fragmentIR(children) {
+	return {
+		id: id(),
+		kind: "Fragment",
+		children
+	};
+}
+function staticAttrIR(name, value) {
+	return {
+		id: id(),
+		kind: "StaticAttribute",
+		name,
+		value
+	};
+}
+function attrBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "AttrBinding",
+		name,
+		expr
+	};
+}
+function propBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "PropBinding",
+		name,
+		expr
+	};
+}
+function eventBindingIR(eventName, handler) {
+	return {
+		id: id(),
+		kind: "EventBinding",
+		eventName,
+		handler
+	};
+}
+function refBindingIR(expr) {
+	return {
+		id: id(),
+		kind: "RefBinding",
+		expr
+	};
+}
+function componentIR(input) {
+	return {
+		id: id(),
+		kind: "Component",
+		ref: input.ref,
+		callee: input.callee,
+		props: input.props
+	};
+}
+function showIR(input) {
+	return {
+		id: id(),
+		kind: "Show",
+		ref: input.ref,
+		when: input.when,
+		children: input.children,
+		fallback: input.fallback
+	};
+}
+function forIR(input) {
+	return {
+		id: id(),
+		kind: "For",
+		ref: input.ref,
+		each: input.each,
+		by: input.by,
+		item: input.item,
+		index: input.index,
+		body: input.body
+	};
+}
+function hostIR(input) {
+	return {
+		id: id(),
+		kind: "Host",
+		attrs: input.attrs,
+		child: input.child
+	};
+}
+function slotIR(input) {
+	var _input$fallback;
+	return {
+		id: id(),
+		kind: "Slot",
+		ref: input.ref,
+		name: input.name,
+		fallback: (_input$fallback = input.fallback) !== null && _input$fallback !== void 0 ? _input$fallback : []
+	};
+}
+//#endregion
+//#region packages/core/compiler-shared/src/visit.ts
+function visitIR(node, visitor, parent) {
+	var _visitor$enter, _visitor$leave;
+	(_visitor$enter = visitor.enter) === null || _visitor$enter === void 0 || _visitor$enter.call(visitor, node, parent);
+	for (const child of getIRChildren(node)) visitIR(child, visitor, node);
+	(_visitor$leave = visitor.leave) === null || _visitor$leave === void 0 || _visitor$leave.call(visitor, node, parent);
+}
+function getIRChildren(node) {
+	switch (node.kind) {
+		case "Element":
+		case "Fragment": return node.children;
+		case "Component": return node.props.flatMap((prop) => Array.isArray(prop.value) ? prop.value : []);
+		case "Show": return [...node.children, ...Array.isArray(node.fallback) ? node.fallback : []];
+		case "For": return node.body;
+		case "Slot": return node.fallback;
+		case "Host": return node.child ? [node.child] : [];
+		case "Text":
+		case "DynamicText": return [];
+	}
+}
+function getComponentChildren(node) {
+	const prop = node.props.find((prop) => prop.name === "children");
+	return prop && Array.isArray(prop.value) ? prop.value : [];
+}
+//#endregion
+//#region packages/core/compiler-shared/src/assert.ts
+function assertElementIR(node) {
+	if (node.kind !== "Element") throw new Error(`Expected Element IR, received ${node.kind}.`);
+}
+function assertNeverIR(node) {
+	throw new Error(`Unhandled IR node ${node.kind}.`);
+}
+//#endregion
+exports.assertElementIR = assertElementIR;
+exports.assertNeverIR = assertNeverIR;
+exports.attrBindingIR = attrBindingIR;
+exports.componentIR = componentIR;
+exports.dynamicTextIR = dynamicTextIR;
+exports.elementIR = elementIR;
+exports.eventBindingIR = eventBindingIR;
+exports.expressionIR = expressionIR;
+exports.forIR = forIR;
+exports.fragmentIR = fragmentIR;
+exports.getComponentChildren = getComponentChildren;
+exports.getIRChildren = getIRChildren;
+exports.hostIR = hostIR;
+exports.id = id;
+exports.identifierIR = identifierIR;
+exports.propBindingIR = propBindingIR;
+exports.ref = ref;
+exports.refBindingIR = refBindingIR;
+exports.showIR = showIR;
+exports.slotIR = slotIR;
+exports.staticAttrIR = staticAttrIR;
+exports.textIR = textIR;
+exports.visitIR = visitIR;

package/dist/compiler-shared.d.ts

@@ -0,0 +1,227 @@
+export interface SourcePosition {
+    line: number;
+    column: number;
+    offset?: number;
+}
+export interface SourceSpan {
+    start: SourcePosition;
+    end: SourcePosition;
+}
+export interface ExpressionIR {
+    kind: 'Expression';
+    code: string;
+    span?: SourceSpan;
+}
+export interface IdentifierIR {
+    kind: 'Identifier';
+    name: string;
+    span?: SourceSpan;
+}
+export interface IRRef {
+    name: string;
+}
+export type DomPath = {
+    kind: 'Root';
+} | {
+    kind: 'FirstChild';
+    parent: IRRef;
+} | {
+    kind: 'NextSibling';
+    previous: IRRef;
+} | {
+    kind: 'Child';
+    parent: IRRef;
+    index: number;
+} | {
+    kind: 'Marker';
+    parent: IRRef;
+    index: number;
+};
+export type PhysicalDomPath = {
+    kind: 'Root';
+} | {
+    kind: 'FirstChild';
+    parent: IRRef;
+} | {
+    kind: 'NextSibling';
+    previous: IRRef;
+} | {
+    kind: 'ChildNode';
+    parent: IRRef;
+    index: number;
+};
+export interface SemanticBaseIRNode {
+    id: number;
+    span?: SourceSpan;
+}
+export type ProgramIR = SemanticBaseIRNode & {
+    kind: 'Program';
+    body: ZeusIRNode[];
+};
+export type ElementIR = SemanticBaseIRNode & {
+    kind: 'Element';
+    ref: IRRef;
+    tagName: string;
+    attrs: AttributeIR[];
+    children: ZeusIRNode[];
+    domPath?: DomPath;
+    physicalDomPath?: PhysicalDomPath;
+    flags: {
+        isSVG: boolean;
+        isVoid: boolean;
+        isCustomElement: boolean;
+    };
+};
+export type TextIR = SemanticBaseIRNode & {
+    kind: 'Text';
+    value: string;
+};
+export type DynamicTextIR = SemanticBaseIRNode & {
+    kind: 'DynamicText';
+    expr: ExpressionIR;
+    ref: IRRef;
+    once?: boolean;
+    domPath?: DomPath;
+    physicalDomPath?: PhysicalDomPath;
+};
+export type StaticAttributeIR = SemanticBaseIRNode & {
+    kind: 'StaticAttribute';
+    name: string;
+    value: string | true;
+};
+export type AttrBindingIR = SemanticBaseIRNode & {
+    kind: 'AttrBinding';
+    name: string;
+    expr: ExpressionIR;
+};
+export type PropBindingIR = SemanticBaseIRNode & {
+    kind: 'PropBinding';
+    name: string;
+    expr: ExpressionIR;
+};
+export type EventBindingIR = SemanticBaseIRNode & {
+    kind: 'EventBinding';
+    eventName: string;
+    handler: ExpressionIR;
+};
+export type RefBindingIR = SemanticBaseIRNode & {
+    kind: 'RefBinding';
+    expr: ExpressionIR;
+};
+export type AttributeIR = StaticAttributeIR | AttrBindingIR | PropBindingIR | EventBindingIR | RefBindingIR;
+export interface ComponentPropIR {
+    name: string;
+    value: ExpressionIR | ZeusIRNode[];
+}
+export type ComponentIR = SemanticBaseIRNode & {
+    kind: 'Component';
+    ref: IRRef;
+    callee: ExpressionIR;
+    props: ComponentPropIR[];
+    domPath?: DomPath;
+    physicalDomPath?: PhysicalDomPath;
+};
+export type FragmentIR = SemanticBaseIRNode & {
+    kind: 'Fragment';
+    children: ZeusIRNode[];
+};
+export type ShowIR = SemanticBaseIRNode & {
+    kind: 'Show';
+    ref: IRRef;
+    when: ExpressionIR;
+    children: ZeusIRNode[];
+    fallback?: ExpressionIR | ZeusIRNode[];
+    domPath?: DomPath;
+    physicalDomPath?: PhysicalDomPath;
+};
+export type ForIR = SemanticBaseIRNode & {
+    kind: 'For';
+    ref: IRRef;
+    each: ExpressionIR;
+    by?: ExpressionIR;
+    item: IdentifierIR;
+    index?: IdentifierIR;
+    body: ZeusIRNode[];
+    domPath?: DomPath;
+    physicalDomPath?: PhysicalDomPath;
+};
+export type HostAttrIR = SemanticBaseIRNode & {
+    kind: 'HostAttr';
+    name: string;
+    expr: ExpressionIR;
+};
+export type HostIR = SemanticBaseIRNode & {
+    kind: 'Host';
+    attrs: HostAttrIR[];
+    child?: ZeusIRNode;
+};
+export type SlotIR = SemanticBaseIRNode & {
+    kind: 'Slot';
+    ref: IRRef;
+    name?: string;
+    fallback: ZeusIRNode[];
+    domPath?: DomPath;
+    physicalDomPath?: PhysicalDomPath;
+};
+export type ZeusIRNode = ElementIR | TextIR | DynamicTextIR | ComponentIR | FragmentIR | ShowIR | ForIR | HostIR | SlotIR;
+
+export declare function id(): number;
+export declare function ref(name: string): IRRef;
+export declare function expressionIR(code: string, span?: SourceSpan): ExpressionIR;
+export declare function identifierIR(name: string, span?: SourceSpan): IdentifierIR;
+export declare function elementIR(input: {
+    ref: IRRef;
+    tagName: string;
+    attrs?: ElementIR['attrs'];
+    children?: ZeusIRNode[];
+    flags?: Partial<ElementIR['flags']>;
+}): ElementIR;
+export declare function textIR(value: string): TextIR;
+export declare function dynamicTextIR(expr: ExpressionIR, nodeRef: IRRef, once?: boolean): DynamicTextIR;
+export declare function fragmentIR(children: ZeusIRNode[]): FragmentIR;
+export declare function staticAttrIR(name: string, value: string | true): StaticAttributeIR;
+export declare function attrBindingIR(name: string, expr: ExpressionIR): AttrBindingIR;
+export declare function propBindingIR(name: string, expr: ExpressionIR): PropBindingIR;
+export declare function eventBindingIR(eventName: string, handler: ExpressionIR): EventBindingIR;
+export declare function refBindingIR(expr: ExpressionIR): RefBindingIR;
+export declare function componentIR(input: {
+    ref: IRRef;
+    callee: ExpressionIR;
+    props: ComponentIR['props'];
+}): ComponentIR;
+export declare function showIR(input: {
+    ref: IRRef;
+    when: ExpressionIR;
+    children: ZeusIRNode[];
+    fallback?: ExpressionIR | ZeusIRNode[];
+}): ShowIR;
+export declare function forIR(input: {
+    ref: IRRef;
+    each: ExpressionIR;
+    by?: ExpressionIR;
+    item: IdentifierIR;
+    index?: IdentifierIR;
+    body: ZeusIRNode[];
+}): ForIR;
+export declare function hostIR(input: {
+    attrs: HostAttrIR[];
+    child?: ZeusIRNode;
+}): HostIR;
+export declare function slotIR(input: {
+    ref: IRRef;
+    name?: string;
+    fallback?: ZeusIRNode[];
+}): SlotIR;
+
+export interface IRVisitor {
+    enter?: (node: ZeusIRNode, parent?: ZeusIRNode) => void;
+    leave?: (node: ZeusIRNode, parent?: ZeusIRNode) => void;
+}
+export declare function visitIR(node: ZeusIRNode, visitor: IRVisitor, parent?: ZeusIRNode): void;
+export declare function getIRChildren(node: ZeusIRNode): ZeusIRNode[];
+export declare function getComponentChildren(node: ComponentIR): ZeusIRNode[];
+
+export declare function assertElementIR(node: ZeusIRNode): asserts node is ElementIR;
+export declare function assertNeverIR(node: never): never;
+
+

package/dist/compiler-shared.esm-bundler.js

@@ -0,0 +1,250 @@
+/**
+* compiler-shared v0.1.0-beta.9
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+//#endregion
+//#region packages/core/compiler-shared/src/semanticBuilders.ts
+let nextId = 0;
+function id() {
+	return nextId++;
+}
+function ref(name) {
+	return { name };
+}
+function expressionIR(code, span) {
+	return {
+		kind: "Expression",
+		code,
+		span
+	};
+}
+function identifierIR(name, span) {
+	return {
+		kind: "Identifier",
+		name,
+		span
+	};
+}
+function elementIR(input) {
+	var _input$attrs, _input$children;
+	return {
+		id: id(),
+		kind: "Element",
+		ref: input.ref,
+		tagName: input.tagName,
+		attrs: (_input$attrs = input.attrs) !== null && _input$attrs !== void 0 ? _input$attrs : [],
+		children: (_input$children = input.children) !== null && _input$children !== void 0 ? _input$children : [],
+		flags: _objectSpread2({
+			isSVG: false,
+			isVoid: false,
+			isCustomElement: input.tagName.includes("-")
+		}, input.flags)
+	};
+}
+function textIR(value) {
+	return {
+		id: id(),
+		kind: "Text",
+		value
+	};
+}
+function dynamicTextIR(expr, nodeRef, once = false) {
+	return {
+		id: id(),
+		kind: "DynamicText",
+		expr,
+		ref: nodeRef,
+		once
+	};
+}
+function fragmentIR(children) {
+	return {
+		id: id(),
+		kind: "Fragment",
+		children
+	};
+}
+function staticAttrIR(name, value) {
+	return {
+		id: id(),
+		kind: "StaticAttribute",
+		name,
+		value
+	};
+}
+function attrBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "AttrBinding",
+		name,
+		expr
+	};
+}
+function propBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "PropBinding",
+		name,
+		expr
+	};
+}
+function eventBindingIR(eventName, handler) {
+	return {
+		id: id(),
+		kind: "EventBinding",
+		eventName,
+		handler
+	};
+}
+function refBindingIR(expr) {
+	return {
+		id: id(),
+		kind: "RefBinding",
+		expr
+	};
+}
+function componentIR(input) {
+	return {
+		id: id(),
+		kind: "Component",
+		ref: input.ref,
+		callee: input.callee,
+		props: input.props
+	};
+}
+function showIR(input) {
+	return {
+		id: id(),
+		kind: "Show",
+		ref: input.ref,
+		when: input.when,
+		children: input.children,
+		fallback: input.fallback
+	};
+}
+function forIR(input) {
+	return {
+		id: id(),
+		kind: "For",
+		ref: input.ref,
+		each: input.each,
+		by: input.by,
+		item: input.item,
+		index: input.index,
+		body: input.body
+	};
+}
+function hostIR(input) {
+	return {
+		id: id(),
+		kind: "Host",
+		attrs: input.attrs,
+		child: input.child
+	};
+}
+function slotIR(input) {
+	var _input$fallback;
+	return {
+		id: id(),
+		kind: "Slot",
+		ref: input.ref,
+		name: input.name,
+		fallback: (_input$fallback = input.fallback) !== null && _input$fallback !== void 0 ? _input$fallback : []
+	};
+}
+//#endregion
+//#region packages/core/compiler-shared/src/visit.ts
+function visitIR(node, visitor, parent) {
+	var _visitor$enter, _visitor$leave;
+	(_visitor$enter = visitor.enter) === null || _visitor$enter === void 0 || _visitor$enter.call(visitor, node, parent);
+	for (const child of getIRChildren(node)) visitIR(child, visitor, node);
+	(_visitor$leave = visitor.leave) === null || _visitor$leave === void 0 || _visitor$leave.call(visitor, node, parent);
+}
+function getIRChildren(node) {
+	switch (node.kind) {
+		case "Element":
+		case "Fragment": return node.children;
+		case "Component": return node.props.flatMap((prop) => Array.isArray(prop.value) ? prop.value : []);
+		case "Show": return [...node.children, ...Array.isArray(node.fallback) ? node.fallback : []];
+		case "For": return node.body;
+		case "Slot": return node.fallback;
+		case "Host": return node.child ? [node.child] : [];
+		case "Text":
+		case "DynamicText": return [];
+	}
+}
+function getComponentChildren(node) {
+	const prop = node.props.find((prop) => prop.name === "children");
+	return prop && Array.isArray(prop.value) ? prop.value : [];
+}
+//#endregion
+//#region packages/core/compiler-shared/src/assert.ts
+function assertElementIR(node) {
+	if (node.kind !== "Element") throw new Error(`Expected Element IR, received ${node.kind}.`);
+}
+function assertNeverIR(node) {
+	throw new Error(`Unhandled IR node ${node.kind}.`);
+}
+//#endregion
+export { assertElementIR, assertNeverIR, attrBindingIR, componentIR, dynamicTextIR, elementIR, eventBindingIR, expressionIR, forIR, fragmentIR, getComponentChildren, getIRChildren, hostIR, id, identifierIR, propBindingIR, ref, refBindingIR, showIR, slotIR, staticAttrIR, textIR, visitIR };

package/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-shared.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-shared.cjs.js')
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@zeus-js/compiler-shared",
+  "type": "module",
+  "version": "0.1.0-beta.9",
+  "description": "Babel-independent Zeus compiler IR contracts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baicie/zeus.git",
+    "directory": "packages/core/compiler-shared"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-shared.d.ts",
+      "module": "./dist/compiler-shared.esm-bundler.js",
+      "import": "./dist/compiler-shared.esm-bundler.js",
+      "require": "./index.js",
+      "node": {
+        "production": "./dist/compiler-shared.cjs.prod.js",
+        "development": "./dist/compiler-shared.cjs.js",
+        "default": "./index.js"
+      }
+    }
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "bugs": {
+    "url": "https://github.com/baicie/zeus/issues"
+  },
+  "buildOptions": {
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "homepage": "https://github.com/baicie/zeus/tree/main/packages/core/compiler-shared#readme",
+  "keywords": [
+    "zeus",
+    "compiler",
+    "ir"
+  ],
+  "main": "index.js",
+  "module": "dist/compiler-shared.esm-bundler.js",
+  "types": "dist/compiler-shared.d.ts"
+}