sketchmark 2.1.1 → 2.1.2

package/dist/src/sequences.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileVisualSequence = compileVisualSequence;
-exports.defaultSequenceId = defaultSequenceId;
-exports.documentForSequenceTime = documentForSequenceTime;
-exports.resolvedFrameForSequenceTime = resolvedFrameForSequenceTime;
-exports.sequenceTimeline = sequenceTimeline;
-const scenes_1 = require("./scenes");
-const normalize_1 = require("./normalize");
-const utils_1 = require("./utils");
-function compileVisualSequence(document, sequenceId) {
-    const sequence = document.sequences?.[sequenceId];
-    if (!sequence)
-        throw new Error(`Unknown sequence '${sequenceId}'.`);
-    let cursor = 0;
-    const clips = sequence.clips.map((clip) => {
-        if (!document.scenes?.[clip.scene])
-            throw new Error(`Unknown scene '${clip.scene}' in sequence '${sequenceId}'.`);
-        const item = { scene: clip.scene, start: cursor, duration: clip.duration, transition: normalizeTransition(clip.transition) };
-        cursor += clip.duration;
-        return item;
-    });
-    return { id: sequenceId, duration: cursor, clips };
-}
-function defaultSequenceId(document) {
-    return Object.keys(document.sequences ?? {})[0];
-}
-function documentForSequenceTime(document, sequenceId, time) {
-    const sequence = compileVisualSequence(document, sequenceId);
-    const clamped = Math.max(0, Math.min(sequence.duration || 0, time));
-    const clipIndex = sequence.clips.findIndex((item) => clamped >= item.start && clamped < item.start + item.duration);
-    const index = clipIndex === -1 ? sequence.clips.length - 1 : clipIndex;
-    const clip = sequence.clips[index];
-    if (!clip)
-        throw new Error(`Sequence '${sequenceId}' has no clips.`);
-    const localTime = Math.max(0, clamped - clip.start);
-    const previous = index > 0 ? sequence.clips[index - 1] : undefined;
-    if (previous && clip.transition.type === "fade" && clip.transition.duration > 0 && localTime < clip.transition.duration) {
-        const progress = Math.max(0, Math.min(1, localTime / clip.transition.duration));
-        return {
-            document: fadeDocuments((0, scenes_1.documentForScene)(document, previous.scene), (0, scenes_1.documentForScene)(document, clip.scene), progress),
-            scene: clip.scene,
-            localTime,
-            globalTime: clamped,
-            transition: { type: "fade", fromScene: previous.scene, toScene: clip.scene, progress, duration: clip.transition.duration }
-        };
-    }
-    return {
-        document: (0, scenes_1.documentForScene)(document, clip.scene),
-        scene: clip.scene,
-        localTime,
-        globalTime: clamped
-    };
-}
-function resolvedFrameForSequenceTime(document, sequenceId, time) {
-    const frame = documentForSequenceTime(document, sequenceId, time);
-    return {
-        ...frame,
-        document: (0, normalize_1.resolveVisualFrame)(frame.document, frame.localTime)
-    };
-}
-function sequenceTimeline(document, sequenceId, fps) {
-    const sequence = compileVisualSequence(document, sequenceId);
-    const safeFps = Math.max(1, Math.round(fps));
-    const frameCount = Math.max(1, Math.ceil(sequence.duration * safeFps));
-    const frames = [];
-    for (let index = 0; index < frameCount; index += 1) {
-        const time = index / safeFps;
-        const frame = documentForSequenceTime(document, sequenceId, time);
-        frames.push({
-            index,
-            time,
-            scene: frame.scene,
-            localTime: frame.localTime,
-            ...(frame.transition ? { transition: frame.transition } : {})
-        });
-    }
-    return frames;
-}
-function normalizeTransition(transition) {
-    if (!transition || transition === "cut")
-        return { type: "cut", duration: 0 };
-    if (transition === "fade")
-        return { type: "fade", duration: 0.4 };
-    return { type: transition.type, duration: Math.max(0, Number(transition.duration ?? (transition.type === "fade" ? 0.4 : 0))) };
-}
-function fadeDocuments(from, to, progress) {
-    const resolvedFrom = (0, normalize_1.normalizeVisualDocument)(from);
-    const resolvedTo = (0, normalize_1.normalizeVisualDocument)(to);
-    return {
-        ...to,
-        elements: [
-            ...withOpacity(resolvedFrom.elements ?? [], 1 - progress, "fade_from"),
-            ...withOpacity(resolvedTo.elements ?? [], progress, "fade_to")
-        ]
-    };
-}
-function withOpacity(elements, multiplier, prefix) {
-    return elements.map((element) => {
-        const next = (0, utils_1.clone)(element);
-        if (next.id)
-            next.id = `${prefix}_${next.id}`;
-        next.opacity = Number(next.opacity ?? 1) * multiplier;
-        if (next.type === "group" && Array.isArray(next.children)) {
-            next.children = withOpacity(next.children, multiplier, prefix);
-        }
-        return next;
-    });
-}

package/dist/src/shapes/builtins.d.ts

@@ -1,2 +0,0 @@
-import type { ShapeDefinition } from "./types";
-export declare const builtInShapeLowerers: ShapeDefinition[];

package/dist/src/shapes/builtins.js

@@ -1,393 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.builtInShapeLowerers = void 0;
-const utils_1 = require("../utils");
-const common_1 = require("./common");
-const geometry_1 = require("./geometry");
-const numberProperty = { type: "number" };
-const stringProperty = { type: "string" };
-const point2Property = { $ref: "#/$defs/point2" };
-const endpointProperty = { $ref: "#/$defs/endpoint" };
-exports.builtInShapeLowerers = [
-    {
-        type: "rect",
-        kind: "2d",
-        schema: { properties: { x: numberProperty, y: numberProperty, width: numberProperty, height: numberProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.x, `${context.path}/x`);
-            context.requireNumber(item.y, `${context.path}/y`);
-            context.requireNumber(item.width, `${context.path}/width`);
-            context.requireNumber(item.height, `${context.path}/height`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.roundedRectPath)(item.x, item.y, item.width, item.height, Number(item.radius ?? 0)));
-        }
-    },
-    {
-        type: "circle",
-        kind: "2d",
-        schema: { properties: { cx: numberProperty, cy: numberProperty, radius: numberProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.cx, `${context.path}/cx`);
-            context.requireNumber(item.cy, `${context.path}/cy`);
-            context.requireNumber(item.radius, `${context.path}/radius`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.circlePath)(item.cx ?? 0, item.cy ?? 0, item.radius));
-        }
-    },
-    {
-        type: "ellipse",
-        kind: "2d",
-        schema: { properties: { cx: numberProperty, cy: numberProperty, rx: numberProperty, ry: numberProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.cx, `${context.path}/cx`);
-            context.requireNumber(item.cy, `${context.path}/cy`);
-            context.requireNumber(item.rx, `${context.path}/rx`);
-            context.requireNumber(item.ry, `${context.path}/ry`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.ellipsePath)(item.cx, item.cy, item.rx, item.ry));
-        }
-    },
-    {
-        type: "line",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { from: endpointProperty, to: endpointProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            if (item.from === undefined)
-                context.addIssue(`${context.path}/from`, "missing_from", "Line/arrow from is required.");
-            if (item.to === undefined)
-                context.addIssue(`${context.path}/to`, "missing_to", "Line/arrow to is required.");
-        },
-        validateReferences(element, context) {
-            const item = element;
-            context.validateEndpoint(item.from, `${context.path}/from`);
-            context.validateEndpoint(item.to, `${context.path}/to`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.linePath)((0, geometry_1.point2)(item.from), (0, geometry_1.point2)(item.to)), { fill: "none", stroke: item.stroke ?? "#111827" });
-        }
-    },
-    {
-        type: "arrow",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { from: endpointProperty, to: endpointProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            if (item.from === undefined)
-                context.addIssue(`${context.path}/from`, "missing_from", "Line/arrow from is required.");
-            if (item.to === undefined)
-                context.addIssue(`${context.path}/to`, "missing_to", "Line/arrow to is required.");
-        },
-        validateReferences(element, context) {
-            const item = element;
-            context.validateEndpoint(item.from, `${context.path}/from`);
-            context.validateEndpoint(item.to, `${context.path}/to`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.linePath)((0, geometry_1.point2)(item.from), (0, geometry_1.point2)(item.to)), {
-                fill: "none",
-                stroke: item.stroke ?? "#111827",
-                metadata: { ...(item.metadata ?? {}), markerEnd: "arrow" }
-            });
-        }
-    },
-    {
-        type: "arc",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { cx: numberProperty, cy: numberProperty, radius: numberProperty, startAngle: numberProperty, endAngle: numberProperty, counterclockwise: { type: "boolean" }, closed: { type: "boolean" } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.cx, `${context.path}/cx`);
-            context.requireNumber(item.cy, `${context.path}/cy`);
-            context.requireNumber(item.radius, `${context.path}/radius`);
-            context.requireNumber(item.startAngle, `${context.path}/startAngle`);
-            context.requireNumber(item.endAngle, `${context.path}/endAngle`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.arcPath)(item.cx, item.cy, item.radius, item.startAngle, item.endAngle, Boolean(item.counterclockwise), Boolean(item.closed)), {
-                fill: item.closed ? item.fill : "none"
-            });
-        }
-    },
-    {
-        type: "curve",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { from: endpointProperty, to: endpointProperty, control1: point2Property, control2: point2Property } },
-        validateGeometry(element, context) {
-            const item = element;
-            if (item.from === undefined)
-                context.addIssue(`${context.path}/from`, "missing_from", "Curve from is required.");
-            if (item.to === undefined)
-                context.addIssue(`${context.path}/to`, "missing_to", "Curve to is required.");
-            context.requirePoint2(item.control1, `${context.path}/control1`, "missing_control1", "Curve control1 must be [x,y].");
-            if (item.control2 !== undefined)
-                context.requirePoint2(item.control2, `${context.path}/control2`, "invalid_control2", "Curve control2 must be [x,y].");
-        },
-        validateReferences(element, context) {
-            const item = element;
-            context.validateEndpoint(item.from, `${context.path}/from`);
-            context.validateEndpoint(item.to, `${context.path}/to`);
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.curvePath)((0, geometry_1.point2)(item.from), item.control1, item.control2, (0, geometry_1.point2)(item.to)), { fill: item.fill ?? "none" });
-        }
-    },
-    {
-        type: "polyline",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { points: { type: "array", items: point2Property } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requirePoint2Array(item.points, 2, `${context.path}/points`, "missing_points", "Polyline points must contain at least two [x,y] points.");
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.pointsPath)(item.points, false), { fill: "none" });
-        }
-    },
-    {
-        type: "polygon",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { points: { type: "array", items: point2Property } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requirePoint2Array(item.points, 3, `${context.path}/points`, "missing_points", "Polygon points must contain at least three [x,y] points.");
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, (0, geometry_1.pointsPath)(item.points, true));
-        }
-    },
-    {
-        type: "path",
-        kind: "2d",
-        pathQueryable: true,
-        schema: { properties: { d: stringProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            if (typeof item.d !== "string" || !item.d.trim())
-                context.addIssue(`${context.path}/d`, "missing_path_d", "Path d is required.");
-        },
-        lower(element) {
-            const item = element;
-            return (0, common_1.toPath)(item, item.d);
-        }
-    },
-    {
-        type: "text",
-        kind: "2d",
-        schema: { properties: { x: numberProperty, y: numberProperty, text: stringProperty, lines: { type: "array", items: stringProperty } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.x, `${context.path}/x`);
-            context.requireNumber(item.y, `${context.path}/y`);
-            if (typeof item.text !== "string" && !Array.isArray(item.lines))
-                context.addIssue(`${context.path}/text`, "missing_text", "Text content is required. Use text or lines.");
-            if (item.lines !== undefined && (!Array.isArray(item.lines) || item.lines.some((line) => typeof line !== "string"))) {
-                context.addIssue(`${context.path}/lines`, "invalid_text_lines", "Text lines must be an array of strings.");
-            }
-        },
-        validateWarnings(element, context) {
-            const item = element;
-            const lines = Array.isArray(item.lines) && item.lines.length ? item.lines : String(item.text ?? "").split(/\r?\n/);
-            const text = lines.join("\n");
-            if (text.length > 42 && !item.maxWidth && !item.wrap && !item.fit) {
-                context.addWarning(`${context.path}/text`, "long_text_no_wrap", "Long text does not resize or wrap automatically.", "Set maxWidth, wrap, or fit explicitly.");
-            }
-        },
-        lower(element) {
-            const item = element;
-            return {
-                ...(0, common_1.common2d)(item),
-                type: "text",
-                x: item.x,
-                y: item.y,
-                text: item.text,
-                lines: (0, common_1.cloneOptional)(item.lines),
-                align: item.align,
-                valign: item.valign,
-                fontSize: item.fontSize,
-                fontFamily: item.fontFamily,
-                weight: item.weight,
-                fontStyle: item.fontStyle,
-                lineHeight: item.lineHeight,
-                letterSpacing: item.letterSpacing,
-                maxWidth: item.maxWidth,
-                wrap: item.wrap,
-                fit: item.fit
-            };
-        }
-    },
-    {
-        type: "image",
-        kind: "2d",
-        schema: { properties: { src: stringProperty, x: numberProperty, y: numberProperty, width: numberProperty, height: numberProperty, fit: { $ref: "#/$defs/imageFit" }, source: { $ref: "#/$defs/imageSource" } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.x, `${context.path}/x`);
-            context.requireNumber(item.y, `${context.path}/y`);
-            context.requireNumber(item.width, `${context.path}/width`);
-            context.requireNumber(item.height, `${context.path}/height`);
-            if (typeof item.src !== "string")
-                context.addIssue(`${context.path}/src`, "missing_src", "Image src is required.");
-            context.validateImageOptions(item);
-        },
-        lower(element) {
-            const item = element;
-            return {
-                ...(0, common_1.common2d)(item),
-                type: "image",
-                src: item.src,
-                x: item.x,
-                y: item.y,
-                width: item.width,
-                height: item.height,
-                fit: item.fit,
-                source: (0, common_1.cloneOptional)(item.source)
-            };
-        }
-    },
-    {
-        type: "point",
-        kind: "2d",
-        schema: { properties: { x: numberProperty, y: numberProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.x, `${context.path}/x`);
-            context.requireNumber(item.y, `${context.path}/y`);
-        },
-        lower(element) {
-            const item = element;
-            return { ...(0, common_1.common2d)(item), type: "point", x: item.x, y: item.y };
-        }
-    },
-    {
-        type: "group",
-        kind: "2d",
-        schema: { properties: { x: numberProperty, y: numberProperty, children: { type: "array", items: { $ref: "#/$defs/element" } } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requireNumber(item.x, `${context.path}/x`);
-            context.requireNumber(item.y, `${context.path}/y`);
-            if (!Array.isArray(item.children))
-                context.addIssue(`${context.path}/children`, "missing_group_children", "Group children must be an array.");
-        },
-        lower(element, context) {
-            const item = element;
-            return {
-                ...(0, common_1.common2d)(item),
-                type: "group",
-                x: item.x,
-                y: item.y,
-                width: item.width,
-                height: item.height,
-                children: context.lowerElements(item.children ?? [])
-            };
-        }
-    },
-    {
-        type: "cuboid",
-        kind: "3d",
-        schema: { properties: { position: { $ref: "#/$defs/point3" }, size: { $ref: "#/$defs/point3" } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requirePoint3(item.position, `${context.path}/position`, "missing_position", "Cuboid position must be [x,y,z].");
-            context.requirePoint3(item.size, `${context.path}/size`, "missing_size", "Cuboid size must be [width,height,depth].");
-        },
-        lower(element) {
-            const item = element;
-            const geometry = (0, geometry_1.cuboidGeometry)(item.size);
-            return (0, common_1.meshElement)(item, geometry.vertices, geometry.faces, (0, utils_1.clone)(item.position));
-        }
-    },
-    {
-        type: "sphere",
-        kind: "3d",
-        schema: { properties: { position: { $ref: "#/$defs/point3" }, radius: numberProperty } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requirePoint3(item.position, `${context.path}/position`, "missing_position", "Sphere position must be [x,y,z].");
-            context.requireNumber(item.radius, `${context.path}/radius`);
-        },
-        lower(element) {
-            const item = element;
-            const geometry = (0, geometry_1.sphereGeometry)(item.radius);
-            return (0, common_1.meshElement)(item, geometry.vertices, geometry.faces, (0, utils_1.clone)(item.position));
-        }
-    },
-    {
-        type: "plane",
-        kind: "3d",
-        schema: { properties: { position: { $ref: "#/$defs/point3" }, size: point2Property } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requirePoint3(item.position, `${context.path}/position`, "missing_position", "Plane position must be [x,y,z].");
-            context.requirePoint2(item.size, `${context.path}/size`, "missing_size", "Plane size must be [width,height].");
-        },
-        lower(element) {
-            const item = element;
-            const geometry = (0, geometry_1.planeGeometry)(item.size);
-            return (0, common_1.meshElement)(item, geometry.vertices, geometry.faces, (0, utils_1.clone)(item.position));
-        }
-    },
-    {
-        type: "line3d",
-        kind: "3d",
-        schema: { properties: { from: { $ref: "#/$defs/point3" }, to: { $ref: "#/$defs/point3" } } },
-        validateGeometry(element, context) {
-            const item = element;
-            context.requirePoint3(item.from, `${context.path}/from`, "missing_from", "line3d from must be [x,y,z].");
-            context.requirePoint3(item.to, `${context.path}/to`, "missing_to", "line3d to must be [x,y,z].");
-        },
-        lower(element) {
-            const item = element;
-            return { ...(0, common_1.common3d)(item), type: "line3d", from: (0, utils_1.clone)(item.from), to: (0, utils_1.clone)(item.to) };
-        }
-    },
-    {
-        type: "text3d",
-        kind: "3d",
-        schema: { properties: { text: stringProperty, position: { $ref: "#/$defs/point3" } } },
-        validateGeometry(element, context) {
-            const item = element;
-            if (typeof item.text !== "string")
-                context.addIssue(`${context.path}/text`, "missing_text", "text3d text is required.");
-            context.requirePoint3(item.position, `${context.path}/position`, "missing_position", "text3d position must be [x,y,z].");
-        },
-        lower(element) {
-            const item = element;
-            return { ...(0, common_1.common3d)(item), type: "text3d", text: item.text, position: (0, utils_1.clone)(item.position), fontSize: item.fontSize };
-        }
-    },
-    {
-        type: "light",
-        kind: "3d",
-        schema: { properties: { kind: { enum: ["ambient", "directional", "point"] }, position: { $ref: "#/$defs/point3" }, intensity: numberProperty } },
-        validateGeometry() {
-            // Light position is optional for ambient lights and currently permissive for all light kinds.
-        },
-        lower(element) {
-            const item = element;
-            return { ...(0, common_1.common3d)(item), type: "light", kind: item.kind, position: (0, common_1.cloneOptional)(item.position), intensity: item.intensity };
-        }
-    }
-];

package/dist/src/shapes/common.d.ts

@@ -1,9 +0,0 @@
-import type { ClipShape, KernelMesh3dElement, KernelPathElement, MaskShape, Point3, VisualElement } from "../types";
-export declare function toPath(element: VisualElement, d: string, overrides?: Record<string, unknown>): KernelPathElement;
-export declare function common2d(element: VisualElement): Record<string, unknown>;
-export declare function common3d(element: VisualElement): Record<string, unknown>;
-export declare function cleanCommon(element: VisualElement, omit: string[]): Record<string, unknown>;
-export declare function lowerClip(clip: ClipShape | undefined): ClipShape | undefined;
-export declare function lowerMask(mask: MaskShape | undefined): MaskShape | undefined;
-export declare function cloneOptional<T>(value: T | undefined): T | undefined;
-export declare function meshElement(source: VisualElement, vertices: Point3[], faces: number[][], position: Point3): KernelMesh3dElement;

package/dist/src/shapes/common.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPath = toPath;
-exports.common2d = common2d;
-exports.common3d = common3d;
-exports.cleanCommon = cleanCommon;
-exports.lowerClip = lowerClip;
-exports.lowerMask = lowerMask;
-exports.cloneOptional = cloneOptional;
-exports.meshElement = meshElement;
-const utils_1 = require("../utils");
-const geometry_1 = require("./geometry");
-function toPath(element, d, overrides = {}) {
-    const base = common2d(element);
-    return { ...base, ...overrides, type: "path", d };
-}
-function common2d(element) {
-    return cleanCommon(element, ["type", "children"]);
-}
-function common3d(element) {
-    return cleanCommon(element, ["type", "children", "position", "size", "radius"]);
-}
-function cleanCommon(element, omit) {
-    const record = (0, utils_1.clone)(element);
-    for (const key of omit)
-        delete record[key];
-    record.clip = lowerClip(record.clip);
-    record.mask = lowerMask(record.mask);
-    resolveOrigin(element, record);
-    return record;
-}
-function resolveOrigin(element, record) {
-    if ((0, utils_1.isPoint2)(record.origin))
-        return;
-    if ((0, utils_1.isAnchorSpec)(record.origin)) {
-        const box = (0, utils_1.elementBox)(element);
-        if (box)
-            record.origin = (0, utils_1.anchorPoint)(box, record.origin);
-        return;
-    }
-    const box = (0, utils_1.elementBox)(element);
-    if (!box)
-        return;
-    record.origin = (0, utils_1.anchorPoint)(box, { kind: "bounds", u: 0.5, v: 0.5 });
-}
-function lowerClip(clip) {
-    if (!clip)
-        return undefined;
-    if (clip.type === "path")
-        return (0, utils_1.clone)(clip);
-    if (clip.type === "rect")
-        return { type: "path", d: (0, geometry_1.roundedRectPath)(clip.x, clip.y, clip.width, clip.height, Number(clip.radius ?? 0)) };
-    return { type: "path", d: (0, geometry_1.circlePath)(clip.cx, clip.cy, clip.radius) };
-}
-function lowerMask(mask) {
-    if (!mask)
-        return undefined;
-    if (mask.type === "path")
-        return (0, utils_1.clone)(mask);
-    if (mask.type === "rect")
-        return { type: "path", d: (0, geometry_1.roundedRectPath)(mask.x, mask.y, mask.width, mask.height, Number(mask.radius ?? 0)), opacity: mask.opacity };
-    return { type: "path", d: (0, geometry_1.circlePath)(mask.cx, mask.cy, mask.radius), opacity: mask.opacity };
-}
-function cloneOptional(value) {
-    return value === undefined ? undefined : (0, utils_1.clone)(value);
-}
-function meshElement(source, vertices, faces, position) {
-    return {
-        ...common3d(source),
-        type: "mesh3d",
-        vertices,
-        faces,
-        indices: (0, geometry_1.triangulateFaces)(faces),
-        position
-    };
-}

package/dist/src/shapes/geometry.d.ts

@@ -1,22 +0,0 @@
-import type { Point2, Point3 } from "../types";
-export declare function roundedRectPath(x: number, y: number, width: number, height: number, radius: number): string;
-export declare function circlePath(cx: number, cy: number, radius: number): string;
-export declare function ellipsePath(cx: number, cy: number, rx: number, ry: number): string;
-export declare function linePath(from: Point2, to: Point2): string;
-export declare function curvePath(from: Point2, control1: Point2, control2: Point2 | undefined, to: Point2): string;
-export declare function pointsPath(points: Point2[], closed: boolean): string;
-export declare function arcPath(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, counterclockwise: boolean, closed: boolean): string;
-export declare function point2(value: unknown): Point2;
-export declare function cuboidGeometry(size: Point3): {
-    vertices: Point3[];
-    faces: number[][];
-};
-export declare function planeGeometry(size: Point2): {
-    vertices: Point3[];
-    faces: number[][];
-};
-export declare function sphereGeometry(radius: number, segments?: number, rings?: number): {
-    vertices: Point3[];
-    faces: number[][];
-};
-export declare function triangulateFaces(faces: number[][]): number[];