@hirokisakabe/pom 1.4.0 → 2.0.0

package/dist/parseXml.js

@@ -1,7 +1,17 @@
 import { XMLParser } from "fast-xml-parser";
 import { z } from "zod";
 import { inputTextNodeSchema, inputImageNodeSchema, inputTableNodeSchema, inputShapeNodeSchema, inputChartNodeSchema, inputTimelineNodeSchema, inputMatrixNodeSchema, inputTreeNodeSchema, inputFlowNodeSchema, inputProcessArrowNodeSchema, inputLineNodeSchema, inputBaseNodeSchema, } from "./inputSchema.js";
-import { alignItemsSchema, justifyContentSchema, shadowStyleSchema, } from "./types.js";
+import { alignItemsSchema, justifyContentSchema, shadowStyleSchema, processArrowStepSchema, timelineItemSchema, matrixAxisSchema, matrixQuadrantsSchema, matrixItemSchema, flowNodeItemSchema, flowConnectionSchema, chartDataSchema, tableColumnSchema, tableCellSchema, } from "./types.js";
+// ===== ParseXmlError =====
+export class ParseXmlError extends Error {
+    errors;
+    constructor(errors) {
+        const message = `XML validation failed (${errors.length} error${errors.length > 1 ? "s" : ""}):\n${errors.map((e) => `  - ${e}`).join("\n")}`;
+        super(message);
+        this.name = "ParseXmlError";
+        this.errors = errors;
+    }
+}
 // ===== Tag name → POM node type mapping =====
 const TAG_TO_TYPE = {
     Text: "text",
@@ -20,6 +30,8 @@ const TAG_TO_TYPE = {
     HStack: "hstack",
     Layer: "layer",
 };
+// 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;
 }
@@ -52,6 +64,154 @@ const containerShapes = {
 };
 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)
+        return [];
+    return Object.keys(shape).filter((k) => k !== "type");
+}
+function levenshteinDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] =
+                a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1]
+                    : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function findClosestMatch(input, candidates) {
+    const threshold = Math.max(2, Math.floor(input.length / 2));
+    let bestMatch;
+    let bestDistance = Infinity;
+    for (const candidate of candidates) {
+        const dist = levenshteinDistance(input.toLowerCase(), candidate.toLowerCase());
+        if (dist < bestDistance && dist <= threshold) {
+            bestDistance = dist;
+            bestMatch = candidate;
+        }
+    }
+    return bestMatch;
+}
+function getKnownChildAttributes(tagName) {
+    const shape = childElementShapes[tagName];
+    if (!shape)
+        return [];
+    return Object.keys(shape);
+}
+// ===== Leaf node Zod validation schemas =====
+const leafNodeValidationSchemas = {
+    text: inputTextNodeSchema,
+    image: inputImageNodeSchema,
+    table: inputTableNodeSchema,
+    shape: inputShapeNodeSchema,
+    chart: inputChartNodeSchema,
+    timeline: inputTimelineNodeSchema,
+    matrix: inputMatrixNodeSchema,
+    tree: inputTreeNodeSchema,
+    flow: inputFlowNodeSchema,
+    processArrow: inputProcessArrowNodeSchema,
+    line: inputLineNodeSchema,
+};
+function formatZodIssue(issue, tagName) {
+    const path = issue.path;
+    // Skip children-related issues (validated recursively)
+    if (path.length > 0 && path[0] === "children")
+        return null;
+    // Skip "type" field issues (set internally)
+    if (path.length === 1 && path[0] === "type")
+        return null;
+    const attrName = path.length > 0 ? String(path[0]) : undefined;
+    const code = issue.code;
+    if (code === "invalid_type") {
+        // Missing required attribute
+        if (issue.input === undefined) {
+            if (attrName) {
+                return `<${tagName}>: Missing required attribute "${attrName}"`;
+            }
+            return `<${tagName}>: ${issue.message}`;
+        }
+        // Type mismatch
+        if (attrName) {
+            return `<${tagName}>: Invalid type for attribute "${attrName}". ${issue.message}`;
+        }
+        return `<${tagName}>: ${issue.message}`;
+    }
+    if (code === "invalid_value") {
+        if (attrName) {
+            const values = issue.values;
+            if (values) {
+                return `<${tagName}>: Invalid value for attribute "${attrName}". Expected: ${values.map((v) => `"${v}"`).join(", ")}`;
+            }
+            return `<${tagName}>: Invalid value for attribute "${attrName}". ${issue.message}`;
+        }
+        return `<${tagName}>: ${issue.message}`;
+    }
+    if (code === "too_small" || code === "too_big") {
+        if (attrName) {
+            return `<${tagName}>: Invalid value for attribute "${attrName}". ${issue.message}`;
+        }
+        return `<${tagName}>: ${issue.message}`;
+    }
+    // Generic fallback
+    if (attrName) {
+        return `<${tagName}>: Attribute "${attrName}": ${issue.message}`;
+    }
+    return `<${tagName}>: ${issue.message}`;
+}
+// Properties that may be legitimately absent when using child element notation
+// or when the property is optional in practice (even if required in schema).
+const CHILD_ELEMENT_PROPS = {
+    flow: new Set(["nodes", "connections"]),
+    table: new Set(["columns", "rows"]),
+    chart: new Set(["data"]),
+    timeline: new Set(["items"]),
+    matrix: new Set(["axes", "items", "quadrants"]),
+    processArrow: new Set(["steps"]),
+    tree: new Set(["data"]),
+};
+function validateLeafNode(nodeType, result, errors) {
+    const schema = leafNodeValidationSchemas[nodeType];
+    if (!schema)
+        return;
+    const tagName = TYPE_TO_TAG[nodeType] ?? nodeType;
+    const childProps = CHILD_ELEMENT_PROPS[nodeType];
+    const parseResult = schema.safeParse(result);
+    if (!parseResult.success) {
+        const seen = new Set();
+        for (const issue of parseResult.error.issues) {
+            // Skip only top-level missing child-element properties (path.length === 1)
+            // Nested issues (e.g., data.children[0].label) must still be reported
+            if (childProps &&
+                issue.path.length === 1 &&
+                childProps.has(String(issue.path[0])) &&
+                issue.code === "invalid_type" &&
+                issue.input === undefined) {
+                continue;
+            }
+            // Skip issues for universal attributes (x, y)
+            if (issue.path.length > 0 && UNIVERSAL_ATTRS.has(String(issue.path[0]))) {
+                continue;
+            }
+            const msg = formatZodIssue(issue, tagName);
+            if (msg && !seen.has(msg)) {
+                seen.add(msg);
+                errors.push(msg);
+            }
+        }
+    }
+}
 function getDef(schema) {
     return schema._def;
 }
@@ -85,6 +245,7 @@ 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);
@@ -93,34 +254,48 @@ function coerceValue(value, schema) {
         case "number": {
             const num = Number(value);
             if (isNaN(num)) {
-                throw new Error(`Cannot convert "${value}" to number`);
+                return {
+                    value: undefined,
+                    error: `Cannot convert "${value}" to number`,
+                };
             }
-            return num;
+            return { value: num, error: null };
         }
         case "boolean":
             if (value !== "true" && value !== "false") {
-                throw new Error(`Cannot convert "${value}" to boolean (expected "true" or "false")`);
+                return {
+                    value: undefined,
+                    error: `Cannot convert "${value}" to boolean (expected "true" or "false")`,
+                };
             }
-            return value === "true";
+            return { value: value === "true", error: null };
         case "string":
         case "enum":
-            return value;
+            return { value, error: null };
         case "literal": {
             const values = def.values;
             const singleValue = def.value;
-            return values?.[0] ?? singleValue;
+            return { value: values?.[0] ?? singleValue, error: null };
         }
         case "array":
         case "object":
         case "record":
         case "tuple":
-            return JSON.parse(value);
+            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 coerceUnionValue(value, options);
+            return { value: coerceUnionValue(value, options), error: null };
         }
         default:
-            return coerceFallback(value);
+            return { value: coerceFallback(value), error: null };
     }
 }
 function coerceUnionValue(value, options) {
@@ -223,32 +398,312 @@ function getTextContent(node) {
     }
     return textParts.length > 0 ? textParts.join("") : undefined;
 }
+// ===== Child element schemas for type coercion =====
+const childElementShapes = {
+    Step: extractShape(processArrowStepSchema),
+    TimelineItem: extractShape(timelineItemSchema),
+    Axes: extractShape(matrixAxisSchema),
+    Quadrants: extractShape(matrixQuadrantsSchema),
+    MatrixItem: extractShape(matrixItemSchema),
+    FlowNode: extractShape(flowNodeItemSchema),
+    Connection: extractShape(flowConnectionSchema),
+    Column: extractShape(tableColumnSchema),
+    Cell: extractShape(tableCellSchema),
+};
+function coerceChildAttrs(parentTagName, tagName, attrs, errors) {
+    const shape = childElementShapes[tagName];
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (shape && shape[key]) {
+            const coerced = coerceValue(value, shape[key]);
+            if (coerced.error !== null) {
+                errors.push(`<${parentTagName}>.<${tagName}>: ${coerced.error}`);
+            }
+            else {
+                result[key] = coerced.value;
+            }
+        }
+        else if (shape) {
+            // Unknown attribute on child element
+            const knownAttrs = getKnownChildAttributes(tagName);
+            const suggestion = findClosestMatch(key, knownAttrs);
+            errors.push(`<${parentTagName}>.<${tagName}>: Unknown attribute "${key}"${suggestion ? `. Did you mean "${suggestion}"?` : ""}`);
+        }
+        else {
+            result[key] = coerceFallback(value);
+        }
+    }
+    return result;
+}
+function convertProcessArrowChildren(childElements, result, errors) {
+    const steps = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        if (tag !== "Step") {
+            errors.push(`Unknown child element <${tag}> inside <ProcessArrow>. Expected: <Step>`);
+            continue;
+        }
+        steps.push(coerceChildAttrs("ProcessArrow", tag, getAttributes(child), errors));
+    }
+    result.steps = steps;
+}
+function convertTimelineChildren(childElements, result, errors) {
+    const items = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        if (tag !== "TimelineItem") {
+            errors.push(`Unknown child element <${tag}> inside <Timeline>. Expected: <TimelineItem>`);
+            continue;
+        }
+        items.push(coerceChildAttrs("Timeline", tag, getAttributes(child), errors));
+    }
+    result.items = items;
+}
+function convertMatrixChildren(childElements, result, errors) {
+    const items = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        switch (tag) {
+            case "Axes":
+                result.axes = coerceChildAttrs("Matrix", tag, getAttributes(child), errors);
+                break;
+            case "Quadrants":
+                result.quadrants = coerceChildAttrs("Matrix", tag, getAttributes(child), errors);
+                break;
+            case "MatrixItem":
+                items.push(coerceChildAttrs("Matrix", tag, getAttributes(child), errors));
+                break;
+            default:
+                errors.push(`Unknown child element <${tag}> inside <Matrix>. Expected: <Axes>, <Quadrants>, or <MatrixItem>`);
+        }
+    }
+    if (items.length > 0) {
+        result.items = items;
+    }
+}
+function convertFlowChildren(childElements, result, errors) {
+    const nodes = [];
+    const connections = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        switch (tag) {
+            case "FlowNode":
+                nodes.push(coerceChildAttrs("Flow", tag, getAttributes(child), errors));
+                break;
+            case "Connection":
+                connections.push(coerceChildAttrs("Flow", tag, getAttributes(child), errors));
+                break;
+            default:
+                errors.push(`Unknown child element <${tag}> inside <Flow>. Expected: <FlowNode> or <Connection>`);
+        }
+    }
+    if (nodes.length > 0) {
+        result.nodes = nodes;
+    }
+    if (connections.length > 0) {
+        result.connections = connections;
+    }
+}
+function convertChartChildren(childElements, result, errors) {
+    const dataShape = extractShape(chartDataSchema);
+    const data = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        if (tag !== "Series") {
+            errors.push(`Unknown child element <${tag}> inside <Chart>. Expected: <Series>`);
+            continue;
+        }
+        const attrs = getAttributes(child);
+        const series = {
+            labels: [],
+            values: [],
+        };
+        if (attrs.name !== undefined) {
+            const nameSchema = dataShape.name;
+            if (nameSchema) {
+                const coerced = coerceValue(attrs.name, nameSchema);
+                if (coerced.error !== null) {
+                    errors.push(`<Chart>.<Series>: ${coerced.error}`);
+                }
+                else {
+                    series.name = coerced.value;
+                }
+            }
+            else {
+                series.name = attrs.name;
+            }
+        }
+        for (const dp of getChildElements(child)) {
+            const dpTag = getTagName(dp);
+            if (dpTag !== "DataPoint") {
+                errors.push(`Unknown child element <${dpTag}> inside <Series>. Expected: <DataPoint>`);
+                continue;
+            }
+            const dpAttrs = getAttributes(dp);
+            if (dpAttrs.label === undefined) {
+                errors.push('<DataPoint> requires a "label" attribute');
+            }
+            if (dpAttrs.value === undefined) {
+                errors.push('<DataPoint> requires a "value" attribute');
+            }
+            if (dpAttrs.label === undefined || dpAttrs.value === undefined) {
+                continue;
+            }
+            const numValue = Number(dpAttrs.value);
+            if (isNaN(numValue)) {
+                errors.push(`Cannot convert "${dpAttrs.value}" to number in <DataPoint> "value" attribute`);
+                continue;
+            }
+            series.labels.push(dpAttrs.label);
+            series.values.push(numValue);
+        }
+        data.push(series);
+    }
+    result.data = data;
+}
+function convertTableChildren(childElements, result, errors) {
+    const columns = [];
+    const rows = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        switch (tag) {
+            case "Column":
+                columns.push(coerceChildAttrs("Table", tag, getAttributes(child), errors));
+                break;
+            case "Row": {
+                const rowAttrs = getAttributes(child);
+                const cells = [];
+                for (const cellEl of getChildElements(child)) {
+                    const cellTag = getTagName(cellEl);
+                    if (cellTag !== "Cell") {
+                        errors.push(`Unknown child element <${cellTag}> inside <Row>. Expected: <Cell>`);
+                        continue;
+                    }
+                    const cellAttrs = coerceChildAttrs("Row", cellTag, getAttributes(cellEl), errors);
+                    const cellText = getTextContent(cellEl);
+                    if (cellText !== undefined && !("text" in cellAttrs)) {
+                        cellAttrs.text = cellText;
+                    }
+                    cells.push(cellAttrs);
+                }
+                const row = { cells };
+                if (rowAttrs.height !== undefined) {
+                    const h = Number(rowAttrs.height);
+                    if (isNaN(h)) {
+                        errors.push(`Cannot convert "${rowAttrs.height}" to number in <Row> "height" attribute`);
+                    }
+                    else {
+                        row.height = h;
+                    }
+                }
+                rows.push(row);
+                break;
+            }
+            default:
+                errors.push(`Unknown child element <${tag}> inside <Table>. Expected: <Column> or <Row>`);
+        }
+    }
+    if (columns.length > 0) {
+        result.columns = columns;
+    }
+    if (rows.length > 0) {
+        result.rows = rows;
+    }
+}
+function convertTreeItem(element, errors) {
+    const attrs = getAttributes(element);
+    if (attrs.label === undefined) {
+        errors.push('<TreeItem> requires a "label" attribute');
+    }
+    const item = {};
+    if (attrs.label !== undefined) {
+        item.label = attrs.label;
+    }
+    if (attrs.color !== undefined) {
+        item.color = attrs.color;
+    }
+    const children = getChildElements(element);
+    if (children.length > 0) {
+        item.children = children
+            .map((child) => {
+            const tag = getTagName(child);
+            if (tag !== "TreeItem") {
+                errors.push(`Unknown child element <${tag}> inside <TreeItem>. Expected: <TreeItem>`);
+                return null;
+            }
+            return convertTreeItem(child, errors);
+        })
+            .filter((item) => item !== null);
+    }
+    return item;
+}
+function convertTreeChildren(childElements, result, errors) {
+    if (childElements.length !== 1) {
+        errors.push(`<Tree> must have exactly 1 <TreeItem> child element, but got ${childElements.length}`);
+        return;
+    }
+    const child = childElements[0];
+    const tag = getTagName(child);
+    if (tag !== "TreeItem") {
+        errors.push(`Unknown child element <${tag}> inside <Tree>. Expected: <TreeItem>`);
+        return;
+    }
+    result.data = convertTreeItem(child, errors);
+}
+const CHILD_ELEMENT_CONVERTERS = {
+    processArrow: convertProcessArrowChildren,
+    timeline: convertTimelineChildren,
+    matrix: convertMatrixChildren,
+    flow: convertFlowChildren,
+    chart: convertChartChildren,
+    table: convertTableChildren,
+    tree: convertTreeChildren,
+};
 // ===== Node conversion =====
-function convertElement(node) {
+function convertElement(node, errors) {
     const tagName = getTagName(node);
     const nodeType = TAG_TO_TYPE[tagName];
     const attrs = getAttributes(node);
     const childElements = getChildElements(node);
     const textContent = getTextContent(node);
     if (nodeType) {
-        return convertPomNode(nodeType, attrs, childElements, textContent);
+        return convertPomNode(nodeType, tagName, attrs, childElements, textContent, errors);
     }
     else {
-        return convertComponentNode(tagName, attrs, childElements, textContent);
+        errors.push(`Unknown tag: <${tagName}>`);
+        return null;
     }
 }
-function convertPomNode(nodeType, attrs, childElements, textContent) {
+function convertPomNode(nodeType, tagName, attrs, childElements, textContent, errors) {
     const result = { type: nodeType };
     for (const [key, value] of Object.entries(attrs)) {
         if (key === "type")
             continue;
         const propSchema = getPropertySchema(nodeType, key);
         if (propSchema) {
-            result[key] = coerceValue(value, propSchema);
+            const coerced = coerceValue(value, propSchema);
+            if (coerced.error !== null) {
+                errors.push(`<${tagName}>: ${coerced.error}`);
+            }
+            else {
+                result[key] = coerced.value;
+            }
         }
-        else {
+        else if (UNIVERSAL_ATTRS.has(key)) {
+            // Allow universal attributes (e.g., x/y for Layer children)
             result[key] = coerceFallback(value);
         }
+        else {
+            // Unknown attribute
+            const knownAttrs = getKnownAttributes(nodeType);
+            const suggestion = findClosestMatch(key, knownAttrs);
+            if (suggestion) {
+                errors.push(`<${tagName}>: Unknown attribute "${key}". Did you mean "${suggestion}"?`);
+            }
+            else {
+                errors.push(`<${tagName}>: Unknown attribute "${key}"`);
+            }
+        }
     }
     // Text content → text property for nodes that support it
     if (textContent !== undefined && TEXT_CONTENT_NODES.has(nodeType)) {
@@ -256,44 +711,46 @@ function convertPomNode(nodeType, attrs, childElements, textContent) {
             result.text = textContent;
         }
     }
+    // Child element notation for complex properties
+    const childConverter = CHILD_ELEMENT_CONVERTERS[nodeType];
+    if (childConverter && childElements.length > 0) {
+        childConverter(childElements, result, errors);
+    }
     // Children for container nodes
-    if (CONTAINER_TYPES.has(nodeType) && childElements.length > 0) {
-        const convertedChildren = childElements.map(convertElement);
+    else if (CONTAINER_TYPES.has(nodeType) && childElements.length > 0) {
+        const convertedChildren = childElements
+            .map((child) => convertElement(child, errors))
+            .filter((child) => child !== null);
         if (nodeType === "box") {
             if (childElements.length !== 1) {
-                throw new Error(`<Box> must have exactly 1 child element, but got ${childElements.length}`);
+                errors.push(`<Box> must have exactly 1 child element, but got ${childElements.length}`);
+            }
+            if (convertedChildren.length > 0) {
+                result.children = convertedChildren[0];
             }
-            result.children = convertedChildren[0];
         }
         else {
             result.children = convertedChildren;
         }
     }
-    return result;
-}
-function convertComponentNode(tagName, attrs, childElements, textContent) {
-    const props = {};
-    for (const [key, value] of Object.entries(attrs)) {
-        props[key] = coerceFallback(value);
+    // Leaf nodes that shouldn't have child elements
+    else if (!CONTAINER_TYPES.has(nodeType) &&
+        !childConverter &&
+        childElements.length > 0) {
+        errors.push(`<${tagName}>: Unexpected child elements. <${tagName}> does not accept child elements`);
     }
-    if (childElements.length > 0) {
-        props.children = childElements.map(convertElement);
+    // Zod validation for leaf nodes
+    if (!CONTAINER_TYPES.has(nodeType)) {
+        validateLeafNode(nodeType, result, errors);
     }
-    else if (textContent !== undefined) {
-        props.children = textContent;
-    }
-    return {
-        type: "component",
-        name: tagName,
-        props,
-    };
+    return result;
 }
 /**
  * XML 文字列を POMNode 配列に変換する。
  *
  * XML タグは POM ノードタイプにマッピングされ、属性値は Zod スキーマを参照して
  * 適切な型（number, boolean, array, object）に変換される。
- * 組み込みノード以外のタグ名はカスタムコンポーネントとして扱われる。
+ * 未知のタグ名が指定された場合はエラーがスローされる。
  *
  * @example
  * ```typescript
@@ -326,7 +783,13 @@ export function parseXml(xmlString) {
         return [];
     const rootElement = parsed[0];
     const rootChildren = (rootElement["__root__"] ?? []);
-    return rootChildren
+    const errors = [];
+    const nodes = rootChildren
         .filter((child) => !isTextNode(child))
-        .map((child) => convertElement(child));
+        .map((child) => convertElement(child, errors))
+        .filter((child) => child !== null);
+    if (errors.length > 0) {
+        throw new ParseXmlError(errors);
+    }
+    return nodes;
 }

package/dist/renderPptx/renderPptx.d.ts

@@ -3,8 +3,6 @@ type SlidePx = {
     w: number;
     h: number;
 };
-export { createTextOptions, convertUnderline, convertStrike, } from "./textOptions.ts";
-export { PX_PER_IN, pxToIn, pxToPt } from "./units.ts";
 /**
  * PositionedNode ツリーを PptxGenJS スライドに変換する
  * @param pages PositionedNode ツリーの配列（各要素が1ページ）
@@ -13,4 +11,5 @@ export { PX_PER_IN, pxToIn, pxToPt } from "./units.ts";
  * @returns PptxGenJS インスタンス
  */
 export declare function renderPptx(pages: PositionedNode[], slidePx: SlidePx, master?: SlideMasterOptions): import("pptxgenjs").default;
+export {};
 //# sourceMappingURL=renderPptx.d.ts.map

package/dist/renderPptx/renderPptx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderPptx.d.ts","sourceRoot":"","sources":["../../src/renderPptx/renderPptx.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAoBrB,KAAK,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACxC,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,GACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAqJvD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,OAAO,EAChB,MAAM,CAAC,EAAE,kBAAkB,+BAqK5B"}
+{"version":3,"file":"renderPptx.d.ts","sourceRoot":"","sources":["../../src/renderPptx/renderPptx.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAoBrB,KAAK,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAqJxC;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,OAAO,EAChB,MAAM,CAAC,EAAE,kBAAkB,+BAqK5B"}

package/dist/renderPptx/renderPptx.js

@@ -10,8 +10,6 @@ import { convertUnderline, convertStrike } from "./textOptions.js";
 import { getImageData } from "../calcYogaLayout/measureImage.js";
 import { renderBackgroundAndBorder } from "./utils/backgroundBorder.js";
 import { renderTextNode, renderImageNode, renderTableNode, renderShapeNode, renderChartNode, renderTimelineNode, renderMatrixNode, renderTreeNode, renderFlowNode, renderProcessArrowNode, renderLineNode, } from "./nodes/index.js";
-export { createTextOptions, convertUnderline, convertStrike, } from "./textOptions.js";
-export { PX_PER_IN, pxToIn, pxToPt } from "./units.js";
 const DEFAULT_MASTER_NAME = "POM_MASTER";
 /**
  * MasterObject を pptxgenjs の objects 形式に変換する

package/dist/renderPptx/textOptions.d.ts

@@ -19,7 +19,6 @@ type PptxBulletOptions = {
     numberType?: BulletOptions["numberType"];
     numberStartAt?: number;
 };
-export declare function createBulletOptions(bullet: boolean | BulletOptions): PptxBulletOptions | boolean;
 export declare function createTextOptions(node: TextNode): {
     x: number;
     y: number;