@hirokisakabe/pom 5.1.0 → 5.2.1

package/dist/parseXml/parseXml.js

@@ -1,7 +1,6 @@
 import { XMLParser } from "fast-xml-parser";
-import { z } from "zod";
-import { inputTextNodeSchema, inputUlNodeSchema, inputOlNodeSchema, inputLiNodeSchema, inputImageNodeSchema, inputTableNodeSchema, inputShapeNodeSchema, inputChartNodeSchema, inputTimelineNodeSchema, inputMatrixNodeSchema, inputTreeNodeSchema, inputFlowNodeSchema, inputProcessArrowNodeSchema, inputPyramidNodeSchema, inputLineNodeSchema, inputIconNodeSchema, inputBaseNodeSchema, } from "./inputSchema.js";
-import { alignItemsSchema, justifyContentSchema, shadowStyleSchema, processArrowStepSchema, pyramidLevelSchema, timelineItemSchema, matrixAxisSchema, matrixQuadrantsSchema, matrixItemSchema, flowNodeItemSchema, flowConnectionSchema, chartDataSchema, tableColumnSchema, tableCellSchema, } from "../types.js";
+import { inputTextNodeSchema, inputUlNodeSchema, inputOlNodeSchema, inputImageNodeSchema, inputTableNodeSchema, inputShapeNodeSchema, inputChartNodeSchema, inputTimelineNodeSchema, inputMatrixNodeSchema, inputTreeNodeSchema, inputFlowNodeSchema, inputProcessArrowNodeSchema, inputPyramidNodeSchema, inputLineNodeSchema, inputIconNodeSchema, } from "./inputSchema.js";
+import { NODE_COERCION_MAP, CHILD_ELEMENT_COERCION_MAP, coerceWithRule, coerceFallback, getObjectShapeFromRule, isBooleanObjectUnionRule, } from "./coercionRules.js";
 // ===== ParseXmlError =====
 export class ParseXmlError extends Error {
     errors;
@@ -36,52 +35,16 @@ const TAG_TO_TYPE = {
 };
 // Reverse mapping: node type → tag name
 const TYPE_TO_TAG = Object.fromEntries(Object.entries(TAG_TO_TYPE).map(([tag, type]) => [type, tag]));
-function extractShape(schema) {
-    return schema.shape;
-}
-const leafNodeShapes = {
-    text: extractShape(inputTextNodeSchema),
-    image: extractShape(inputImageNodeSchema),
-    table: extractShape(inputTableNodeSchema),
-    shape: extractShape(inputShapeNodeSchema),
-    chart: extractShape(inputChartNodeSchema),
-    timeline: extractShape(inputTimelineNodeSchema),
-    matrix: extractShape(inputMatrixNodeSchema),
-    tree: extractShape(inputTreeNodeSchema),
-    flow: extractShape(inputFlowNodeSchema),
-    processArrow: extractShape(inputProcessArrowNodeSchema),
-    pyramid: extractShape(inputPyramidNodeSchema),
-    line: extractShape(inputLineNodeSchema),
-    ul: extractShape(inputUlNodeSchema),
-    ol: extractShape(inputOlNodeSchema),
-    icon: extractShape(inputIconNodeSchema),
-};
-const containerShapes = {
-    box: extractShape(inputBaseNodeSchema.extend({ shadow: shadowStyleSchema.optional() })),
-    vstack: extractShape(inputBaseNodeSchema.extend({
-        gap: z.number().optional(),
-        alignItems: alignItemsSchema.optional(),
-        justifyContent: justifyContentSchema.optional(),
-        shadow: shadowStyleSchema.optional(),
-    })),
-    hstack: extractShape(inputBaseNodeSchema.extend({
-        gap: z.number().optional(),
-        alignItems: alignItemsSchema.optional(),
-        justifyContent: justifyContentSchema.optional(),
-        shadow: shadowStyleSchema.optional(),
-    })),
-    layer: extractShape(inputBaseNodeSchema),
-};
 const CONTAINER_TYPES = new Set(["box", "vstack", "hstack", "layer"]);
 const TEXT_CONTENT_NODES = new Set(["text", "shape"]);
 // Attributes allowed on any node (e.g., x/y for Layer children positioning)
 const UNIVERSAL_ATTRS = new Set(["x", "y"]);
 // ===== Validation helpers =====
 function getKnownAttributes(nodeType) {
-    const shape = leafNodeShapes[nodeType] ?? containerShapes[nodeType];
-    if (!shape)
+    const rules = NODE_COERCION_MAP[nodeType];
+    if (!rules)
         return [];
-    return Object.keys(shape).filter((k) => k !== "type");
+    return Object.keys(rules);
 }
 function levenshteinDistance(a, b) {
     const m = a.length;
@@ -115,10 +78,10 @@ function findClosestMatch(input, candidates) {
     return bestMatch;
 }
 function getKnownChildAttributes(tagName) {
-    const shape = childElementShapes[tagName];
-    if (!shape)
+    const rules = CHILD_ELEMENT_COERCION_MAP[tagName];
+    if (!rules)
         return [];
-    return Object.keys(shape);
+    return Object.keys(rules);
 }
 // ===== Leaf node Zod validation schemas =====
 const leafNodeValidationSchemas = {
@@ -229,165 +192,11 @@ function validateLeafNode(nodeType, result, errors) {
         }
     }
 }
-function getDef(schema) {
-    return schema._def;
-}
-function getPropertySchema(nodeType, propertyName) {
-    const shape = leafNodeShapes[nodeType] ?? containerShapes[nodeType];
-    if (!shape)
-        return undefined;
-    return shape[propertyName];
-}
-function getZodType(schema) {
-    const def = getDef(schema);
-    return (def.type ?? def.typeName ?? "");
-}
-function unwrapSchema(schema) {
-    const typeName = getZodType(schema);
-    const def = getDef(schema);
-    switch (typeName) {
-        case "optional":
-        case "default":
-        case "nullable":
-            return unwrapSchema(def.innerType);
-        case "lazy":
-            return unwrapSchema(def.getter());
-        case "pipe":
-            return unwrapSchema(def.in);
-        default:
-            return schema;
-    }
-}
-function resolveZodTypeName(schema) {
-    return getZodType(unwrapSchema(schema));
-}
-// ===== Value coercion =====
-// Returns { value, error } — if error is non-null, coercion failed.
-function coerceValue(value, schema) {
-    const unwrapped = unwrapSchema(schema);
-    const typeName = getZodType(unwrapped);
-    const def = getDef(unwrapped);
-    switch (typeName) {
-        case "number": {
-            const num = Number(value);
-            if (isNaN(num)) {
-                return {
-                    value: undefined,
-                    error: `Cannot convert "${value}" to number`,
-                };
-            }
-            return { value: num, error: null };
-        }
-        case "boolean":
-            if (value !== "true" && value !== "false") {
-                return {
-                    value: undefined,
-                    error: `Cannot convert "${value}" to boolean (expected "true" or "false")`,
-                };
-            }
-            return { value: value === "true", error: null };
-        case "string":
-        case "enum":
-            return { value, error: null };
-        case "literal": {
-            const values = def.values;
-            const singleValue = def.value;
-            return { value: values?.[0] ?? singleValue, error: null };
-        }
-        case "array":
-        case "object":
-        case "record":
-        case "tuple":
-            try {
-                return { value: JSON.parse(value), error: null };
-            }
-            catch {
-                return {
-                    value: undefined,
-                    error: `Cannot parse JSON value: "${value}"`,
-                };
-            }
-        case "union": {
-            const options = def.options;
-            return { value: coerceUnionValue(value, options), error: null };
-        }
-        default:
-            return { value: coerceFallback(value), error: null };
-    }
-}
-function coerceUnionValue(value, options) {
-    const typeNames = options.map((opt) => resolveZodTypeName(opt));
-    // Try boolean
-    if ((value === "true" || value === "false") &&
-        typeNames.includes("boolean")) {
-        return value === "true";
-    }
-    // Try number
-    if (typeNames.includes("number")) {
-        const num = Number(value);
-        if (!isNaN(num) && value !== "") {
-            return num;
-        }
-    }
-    // Try literal
-    for (let i = 0; i < options.length; i++) {
-        if (typeNames[i] === "literal") {
-            const unwrapped = unwrapSchema(options[i]);
-            const def = getDef(unwrapped);
-            const values = def.values;
-            const singleValue = def.value;
-            const litVal = values?.[0] ?? singleValue;
-            if (litVal != null && `${litVal}` === value)
-                return litVal;
-        }
-    }
-    // Try JSON parse for objects/arrays
-    if (typeNames.some((t) => ["array", "object", "record", "tuple"].includes(t))) {
-        if (value.startsWith("{") || value.startsWith("[")) {
-            try {
-                return JSON.parse(value);
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    // Fallback to string
-    return value;
-}
-function coerceFallback(value) {
-    if (value === "true")
-        return true;
-    if (value === "false")
-        return false;
-    const num = Number(value);
-    if (value !== "" && !isNaN(num))
-        return num;
-    if (value.startsWith("{") || value.startsWith("[")) {
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return value;
+// ===== Coercion rule lookup =====
+function getCoercionRule(nodeType, propertyName) {
+    return NODE_COERCION_MAP[nodeType]?.[propertyName];
 }
 // ===== Dot notation helpers =====
-/**
- * Checks if a schema is a union containing both boolean and object types.
- * Used to allow `endArrow="true" endArrow.type="triangle"` coexistence.
- */
-function isBooleanObjectUnion(schema) {
-    const unwrapped = unwrapSchema(schema);
-    const typeName = getZodType(unwrapped);
-    if (typeName !== "union")
-        return false;
-    const def = getDef(unwrapped);
-    const options = def.options;
-    const typeNames = options.map((opt) => getZodType(unwrapSchema(opt)));
-    return typeNames.includes("boolean") && typeNames.includes("object");
-}
 // ===== Dot notation expansion =====
 function expandDotNotation(attrs) {
     const regular = {};
@@ -407,26 +216,13 @@ function expandDotNotation(attrs) {
     }
     return { regular, dotGroups };
 }
-function coerceDotGroup(prefix, subAttrs, schema, tagName, errors) {
-    const unwrapped = unwrapSchema(schema);
-    const typeName = getZodType(unwrapped);
-    let objectSchema;
-    if (typeName === "object") {
-        objectSchema = unwrapped;
-    }
-    else if (typeName === "union") {
-        const def = getDef(unwrapped);
-        const options = def.options;
-        objectSchema = options.find((opt) => getZodType(unwrapSchema(opt)) === "object");
-        if (objectSchema)
-            objectSchema = unwrapSchema(objectSchema);
-    }
+function coerceDotGroup(prefix, subAttrs, rule, tagName, errors) {
+    const objectShape = getObjectShapeFromRule(rule);
     const obj = {};
-    if (objectSchema) {
-        const shape = extractShape(objectSchema);
+    if (objectShape) {
         for (const [subKey, subValue] of Object.entries(subAttrs)) {
-            if (shape[subKey]) {
-                const coerced = coerceValue(subValue, shape[subKey]);
+            if (objectShape[subKey]) {
+                const coerced = coerceWithRule(subValue, objectShape[subKey]);
                 if (coerced.error !== null) {
                     errors.push(`<${tagName}>: ${prefix}.${subKey}: ${coerced.error}`);
                 }
@@ -435,7 +231,7 @@ function coerceDotGroup(prefix, subAttrs, schema, tagName, errors) {
                 }
             }
             else {
-                const knownSubKeys = Object.keys(shape);
+                const knownSubKeys = Object.keys(objectShape);
                 const suggestion = findClosestMatch(subKey, knownSubKeys);
                 errors.push(`<${tagName}>: Unknown sub-attribute "${prefix}.${subKey}"${suggestion ? `. Did you mean "${prefix}.${suggestion}"?` : ""}`);
             }
@@ -488,30 +284,16 @@ function getTextContent(node) {
     }
     return textParts.length > 0 ? textParts.join("") : undefined;
 }
-// ===== Child element schemas for type coercion =====
-const childElementShapes = {
-    ProcessArrowStep: extractShape(processArrowStepSchema),
-    PyramidLevel: extractShape(pyramidLevelSchema),
-    TimelineItem: extractShape(timelineItemSchema),
-    MatrixAxes: extractShape(matrixAxisSchema),
-    MatrixQuadrants: extractShape(matrixQuadrantsSchema),
-    MatrixItem: extractShape(matrixItemSchema),
-    FlowNode: extractShape(flowNodeItemSchema),
-    FlowConnection: extractShape(flowConnectionSchema),
-    TableColumn: extractShape(tableColumnSchema),
-    TableCell: extractShape(tableCellSchema),
-    Li: extractShape(inputLiNodeSchema),
-};
 function coerceChildAttrs(parentTagName, tagName, attrs, errors) {
-    const shape = childElementShapes[tagName];
+    const rules = CHILD_ELEMENT_COERCION_MAP[tagName];
     const result = {};
     const { regular: regularAttrs, dotGroups } = expandDotNotation(attrs);
     // Process dot-notation attributes
     for (const [prefix, subAttrs] of Object.entries(dotGroups)) {
-        if (shape && shape[prefix]) {
-            result[prefix] = coerceDotGroup(prefix, subAttrs, shape[prefix], `${parentTagName}.${tagName}`, errors);
+        if (rules && rules[prefix]) {
+            result[prefix] = coerceDotGroup(prefix, subAttrs, rules[prefix], `${parentTagName}.${tagName}`, errors);
         }
-        else if (shape) {
+        else if (rules) {
             const knownAttrs = getKnownChildAttributes(tagName);
             const suggestion = findClosestMatch(prefix, knownAttrs);
             errors.push(`<${parentTagName}>.<${tagName}>: Unknown attribute "${prefix}"${suggestion ? `. Did you mean "${suggestion}"?` : ""}`);
@@ -527,11 +309,11 @@ function coerceChildAttrs(parentTagName, tagName, attrs, errors) {
     // Process regular attributes
     for (const [key, value] of Object.entries(regularAttrs)) {
         if (key in dotGroups) {
-            // When the schema is a union of boolean and object,
+            // When the rule is a union of boolean and object,
             // allow boolean shorthand to coexist with dot-notation by ignoring the boolean value.
-            if (shape &&
-                shape[key] &&
-                isBooleanObjectUnion(shape[key]) &&
+            if (rules &&
+                rules[key] &&
+                isBooleanObjectUnionRule(rules[key]) &&
                 (value === "true" || value === "false")) {
                 // Silently skip the boolean value; dot-notation takes priority
                 continue;
@@ -539,8 +321,8 @@ function coerceChildAttrs(parentTagName, tagName, attrs, errors) {
             errors.push(`<${parentTagName}>.<${tagName}>: Attribute "${key}" conflicts with dot-notation attributes. Use one or the other, not both`);
             continue;
         }
-        if (shape && shape[key]) {
-            const coerced = coerceValue(value, shape[key]);
+        if (rules && rules[key]) {
+            const coerced = coerceWithRule(value, rules[key]);
             if (coerced.error !== null) {
                 errors.push(`<${parentTagName}>.<${tagName}>: ${coerced.error}`);
             }
@@ -548,7 +330,7 @@ function coerceChildAttrs(parentTagName, tagName, attrs, errors) {
                 result[key] = coerced.value;
             }
         }
-        else if (shape) {
+        else if (rules) {
             // Unknown attribute on child element
             const knownAttrs = getKnownChildAttributes(tagName);
             const suggestion = findClosestMatch(key, knownAttrs);
@@ -642,7 +424,6 @@ function convertFlowChildren(childElements, result, errors) {
     }
 }
 function convertChartChildren(childElements, result, errors) {
-    const dataShape = extractShape(chartDataSchema);
     const data = [];
     for (const child of childElements) {
         const tag = getTagName(child);
@@ -656,19 +437,8 @@ function convertChartChildren(childElements, result, errors) {
             values: [],
         };
         if (attrs.name !== undefined) {
-            const nameSchema = dataShape.name;
-            if (nameSchema) {
-                const coerced = coerceValue(attrs.name, nameSchema);
-                if (coerced.error !== null) {
-                    errors.push(`<Chart>.<ChartSeries>: ${coerced.error}`);
-                }
-                else {
-                    series.name = coerced.value;
-                }
-            }
-            else {
-                series.name = attrs.name;
-            }
+            // chartDataSchema.name は z.string().optional() なのでそのまま文字列として使用
+            series.name = attrs.name;
         }
         for (const dp of getChildElements(child)) {
             const dpTag = getTagName(dp);
@@ -838,9 +608,9 @@ function convertPomNode(nodeType, tagName, attrs, childElements, textContent, er
     for (const [prefix, subAttrs] of Object.entries(dotGroups)) {
         if (prefix === "type")
             continue;
-        const propSchema = getPropertySchema(nodeType, prefix);
-        if (propSchema) {
-            result[prefix] = coerceDotGroup(prefix, subAttrs, propSchema, tagName, errors);
+        const rule = getCoercionRule(nodeType, prefix);
+        if (rule) {
+            result[prefix] = coerceDotGroup(prefix, subAttrs, rule, tagName, errors);
         }
         else {
             const knownAttrs = getKnownAttributes(nodeType);
@@ -858,11 +628,11 @@ function convertPomNode(nodeType, tagName, attrs, childElements, textContent, er
             continue;
         // Conflict check: dot-notation and regular attribute for the same key
         if (key in dotGroups) {
-            // When the schema is a union of boolean and object (e.g., endArrow),
+            // When the rule is a union of boolean and object (e.g., endArrow),
             // allow boolean shorthand to coexist with dot-notation by ignoring the boolean value.
-            const propSchemaForConflict = getPropertySchema(nodeType, key);
-            if (propSchemaForConflict &&
-                isBooleanObjectUnion(propSchemaForConflict) &&
+            const ruleForConflict = getCoercionRule(nodeType, key);
+            if (ruleForConflict &&
+                isBooleanObjectUnionRule(ruleForConflict) &&
                 (value === "true" || value === "false")) {
                 // Silently skip the boolean value; dot-notation takes priority
                 continue;
@@ -870,9 +640,9 @@ function convertPomNode(nodeType, tagName, attrs, childElements, textContent, er
             errors.push(`<${tagName}>: Attribute "${key}" conflicts with dot-notation attributes (e.g., "${key}.xxx"). Use one or the other, not both`);
             continue;
         }
-        const propSchema = getPropertySchema(nodeType, key);
-        if (propSchema) {
-            const coerced = coerceValue(value, propSchema);
+        const rule = getCoercionRule(nodeType, key);
+        if (rule) {
+            const coerced = coerceWithRule(value, rule);
             if (coerced.error !== null) {
                 errors.push(`<${tagName}>: ${coerced.error}`);
             }

package/dist/registry/definitions/box.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from "../types.ts";
+export declare const boxNodeDef: NodeDefinition;
+//# sourceMappingURL=box.d.ts.map

package/dist/registry/definitions/box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box.d.ts","sourceRoot":"","sources":["../../../src/registry/definitions/box.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,eAAO,MAAM,UAAU,EAAE,cAKxB,CAAC"}

package/dist/registry/definitions/box.js

@@ -0,0 +1,6 @@
+export const boxNodeDef = {
+    type: "box",
+    category: "single-child",
+    // applyYogaStyle: デフォルトで十分（共通スタイルのみ）
+    // render: category ベースの子要素再帰で対応
+};

package/dist/registry/definitions/chart.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from "../types.ts";
+export declare const chartNodeDef: NodeDefinition;
+//# sourceMappingURL=chart.d.ts.map

package/dist/registry/definitions/chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart.d.ts","sourceRoot":"","sources":["../../../src/registry/definitions/chart.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,eAAO,MAAM,YAAY,EAAE,cAM1B,CAAC"}

package/dist/registry/definitions/chart.js

@@ -0,0 +1,8 @@
+import { renderChartNode } from "../../renderPptx/nodes/chart.js";
+export const chartNodeDef = {
+    type: "chart",
+    category: "leaf",
+    render(node, ctx) {
+        renderChartNode(node, ctx);
+    },
+};

package/dist/registry/definitions/compositeNodes.d.ts

@@ -0,0 +1,8 @@
+import type { NodeDefinition } from "../types.ts";
+export declare const timelineNodeDef: NodeDefinition;
+export declare const matrixNodeDef: NodeDefinition;
+export declare const treeNodeDef: NodeDefinition;
+export declare const flowNodeDef: NodeDefinition;
+export declare const processArrowNodeDef: NodeDefinition;
+export declare const pyramidNodeDef: NodeDefinition;
+//# sourceMappingURL=compositeNodes.d.ts.map

package/dist/registry/definitions/compositeNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeNodes.d.ts","sourceRoot":"","sources":["../../../src/registry/definitions/compositeNodes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAQ,MAAM,aAAa,CAAC;AAqDxD,eAAO,MAAM,eAAe,EAAE,cAS7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,cAS3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,cASzB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,cASzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,cAYjC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAS5B,CAAC"}

package/dist/registry/definitions/compositeNodes.js

@@ -0,0 +1,81 @@
+import { measureProcessArrow, measureTimeline, measureMatrix, measureTree, measureFlow, measurePyramid, } from "../../calcYogaLayout/measureCompositeNodes.js";
+import { renderTimelineNode } from "../../renderPptx/nodes/timeline.js";
+import { renderMatrixNode } from "../../renderPptx/nodes/matrix.js";
+import { renderTreeNode } from "../../renderPptx/nodes/tree.js";
+import { renderFlowNode } from "../../renderPptx/nodes/flow.js";
+import { renderProcessArrowNode } from "../../renderPptx/nodes/processArrow.js";
+import { renderPyramidNode } from "../../renderPptx/nodes/pyramid.js";
+/**
+ * コンポジットノードの最小スケール閾値。
+ * renderPptx/utils/scaleToFit.ts の MIN_SCALE_THRESHOLD と同じ値を維持すること。
+ */
+const MIN_SCALE_THRESHOLD = 0.5;
+/** 制約付きサイズを閾値でクランプする */
+function constrainWithMinScale(intrinsicSize, availableSize) {
+    const minSize = intrinsicSize * MIN_SCALE_THRESHOLD;
+    return Math.max(minSize, Math.min(intrinsicSize, availableSize));
+}
+/** コンポジットノード共通の measureFunc セットアップ */
+function applyCompositeMeasure(measureFn) {
+    return (node, yn, yoga) => {
+        yn.setMeasureFunc((width, widthMode, height, heightMode) => {
+            const intrinsic = measureFn(node);
+            return {
+                width: widthMode !== yoga.MEASURE_MODE_UNDEFINED
+                    ? constrainWithMinScale(intrinsic.width, width)
+                    : intrinsic.width,
+                height: heightMode !== yoga.MEASURE_MODE_UNDEFINED
+                    ? constrainWithMinScale(intrinsic.height, height)
+                    : intrinsic.height,
+            };
+        });
+    };
+}
+export const timelineNodeDef = {
+    type: "timeline",
+    category: "leaf",
+    applyYogaStyle: applyCompositeMeasure(measureTimeline),
+    render(node, ctx) {
+        renderTimelineNode(node, ctx);
+    },
+};
+export const matrixNodeDef = {
+    type: "matrix",
+    category: "leaf",
+    applyYogaStyle: applyCompositeMeasure(measureMatrix),
+    render(node, ctx) {
+        renderMatrixNode(node, ctx);
+    },
+};
+export const treeNodeDef = {
+    type: "tree",
+    category: "leaf",
+    applyYogaStyle: applyCompositeMeasure(measureTree),
+    render(node, ctx) {
+        renderTreeNode(node, ctx);
+    },
+};
+export const flowNodeDef = {
+    type: "flow",
+    category: "leaf",
+    applyYogaStyle: applyCompositeMeasure(measureFlow),
+    render(node, ctx) {
+        renderFlowNode(node, ctx);
+    },
+};
+export const processArrowNodeDef = {
+    type: "processArrow",
+    category: "leaf",
+    applyYogaStyle: applyCompositeMeasure(measureProcessArrow),
+    render(node, ctx) {
+        renderProcessArrowNode(node, ctx);
+    },
+};
+export const pyramidNodeDef = {
+    type: "pyramid",
+    category: "leaf",
+    applyYogaStyle: applyCompositeMeasure(measurePyramid),
+    render(node, ctx) {
+        renderPyramidNode(node, ctx);
+    },
+};

package/dist/registry/definitions/icon.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from "../types.ts";
+export declare const iconNodeDef: NodeDefinition;
+//# sourceMappingURL=icon.d.ts.map

package/dist/registry/definitions/icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon.d.ts","sourceRoot":"","sources":["../../../src/registry/definitions/icon.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,eAAO,MAAM,WAAW,EAAE,cAiCzB,CAAC"}

package/dist/registry/definitions/icon.js

@@ -0,0 +1,28 @@
+import { rasterizeIcon } from "../../icons/index.js";
+import { omitYogaNode } from "../../toPositioned/toPositioned.js";
+import { renderIconNode } from "../../renderPptx/nodes/icon.js";
+export const iconNodeDef = {
+    type: "icon",
+    category: "leaf",
+    applyYogaStyle(node, yn) {
+        const n = node;
+        const size = n.size ?? 24;
+        yn.setMeasureFunc(() => ({ width: size, height: size }));
+    },
+    toPositioned(pom, absoluteX, absoluteY, layout, ctx) {
+        const n = pom;
+        const rasterSize = Math.max(Math.ceil(layout.width), Math.ceil(layout.height), n.size ?? 24);
+        const iconImageData = rasterizeIcon(n.name, rasterSize, n.color ?? "#000000", ctx.iconRasterCache);
+        return {
+            ...omitYogaNode(n),
+            x: absoluteX,
+            y: absoluteY,
+            w: layout.width,
+            h: layout.height,
+            iconImageData,
+        };
+    },
+    render(node, ctx) {
+        renderIconNode(node, ctx);
+    },
+};

package/dist/registry/definitions/image.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from "../types.ts";
+export declare const imageNodeDef: NodeDefinition;
+//# sourceMappingURL=image.d.ts.map

package/dist/registry/definitions/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/registry/definitions/image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAQ,MAAM,aAAa,CAAC;AAOxD,eAAO,MAAM,YAAY,EAAE,cA+B1B,CAAC"}

package/dist/registry/definitions/image.js

@@ -0,0 +1,34 @@
+import { measureImage, getImageData } from "../../shared/measureImage.js";
+import { renderImageNode } from "../../renderPptx/nodes/image.js";
+import { omitYogaNode } from "../../toPositioned/toPositioned.js";
+export const imageNodeDef = {
+    type: "image",
+    category: "leaf",
+    applyYogaStyle(node, yn, _yoga, ctx) {
+        const n = node;
+        const src = n.src;
+        yn.setMeasureFunc(() => {
+            const { widthPx, heightPx } = measureImage(src, ctx.imageSizeCache);
+            return { width: widthPx, height: heightPx };
+        });
+    },
+    toPositioned(pom, absoluteX, absoluteY, layout, ctx) {
+        const n = pom;
+        const imageData = getImageData(n.src, ctx.imageDataCache);
+        return {
+            ...omitYogaNode(n),
+            x: absoluteX,
+            y: absoluteY,
+            w: layout.width,
+            h: layout.height,
+            imageData,
+        };
+    },
+    render(node, ctx) {
+        renderImageNode(node, ctx);
+    },
+    collectImageSources(node) {
+        const n = node;
+        return [n.src];
+    },
+};

package/dist/registry/definitions/layer.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from "../types.ts";
+export declare const layerNodeDef: NodeDefinition;
+//# sourceMappingURL=layer.d.ts.map

package/dist/registry/definitions/layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../../src/registry/definitions/layer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,eAAO,MAAM,YAAY,EAAE,cAwD1B,CAAC"}