sketchmark 2.1.1 → 2.1.3

package/dist/src/compounds.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileCompounds = compileCompounds;
-const builders_1 = require("./builders");
-const utils_1 = require("./utils");
-function compileCompounds(input) {
-    const document = (0, utils_1.clone)(input);
-    const elements = compileElementList(document.elements ?? []);
-    const scenes = {};
-    for (const [sceneId, scene] of Object.entries(document.scenes ?? {})) {
-        scenes[sceneId] = {
-            ...scene,
-            elements: compileElementList(scene.elements ?? [])
-        };
-    }
-    return {
-        ...document,
-        elements,
-        ...(Object.keys(scenes).length ? { scenes } : {})
-    };
-}
-function compileElementList(elements) {
-    return elements.flatMap((element) => compileElement(element));
-}
-function compileElement(element) {
-    switch (element.type) {
-        case "node":
-            return (0, builders_1.node)({
-                id: stringProp(element, "id"),
-                label: stringProp(element, "label"),
-                x: numberProp(element, "x"),
-                y: numberProp(element, "y"),
-                width: numberProp(element, "width"),
-                height: numberProp(element, "height"),
-                radius: optionalNumber(element, "radius"),
-                fill: optionalString(element, "fill"),
-                stroke: optionalString(element, "stroke"),
-                strokeWidth: optionalNumber(element, "strokeWidth"),
-                fontSize: optionalNumber(element, "fontSize"),
-                textFill: optionalString(element, "textFill")
-            });
-        case "flow":
-            return (0, builders_1.flow)({
-                id: stringProp(element, "id"),
-                from: element.from,
-                to: element.to,
-                stroke: optionalString(element, "stroke"),
-                strokeWidth: optionalNumber(element, "strokeWidth"),
-                label: optionalString(element, "label"),
-                labelX: optionalNumber(element, "labelX"),
-                labelY: optionalNumber(element, "labelY")
-            });
-        case "packet":
-            return [
-                (0, builders_1.packet)({
-                    id: stringProp(element, "id"),
-                    on: stringProp(element, "on"),
-                    radius: optionalNumber(element, "radius"),
-                    fill: optionalString(element, "fill"),
-                    progress: element.progress
-                })
-            ];
-        case "callout":
-            return (0, builders_1.callout)({
-                id: stringProp(element, "id"),
-                text: stringProp(element, "text"),
-                x: numberProp(element, "x"),
-                y: numberProp(element, "y"),
-                width: numberProp(element, "width"),
-                height: numberProp(element, "height"),
-                target: element.target,
-                fill: optionalString(element, "fill"),
-                textFill: optionalString(element, "textFill"),
-                stroke: optionalString(element, "stroke")
-            });
-        case "row":
-            return (0, builders_1.row)({
-                x: numberProp(element, "x"),
-                y: numberProp(element, "y"),
-                gap: optionalNumber(element, "gap"),
-                children: (element.children ?? []).map((child) => compileElement(child))
-            });
-        case "column":
-            return (0, builders_1.column)({
-                x: numberProp(element, "x"),
-                y: numberProp(element, "y"),
-                gap: optionalNumber(element, "gap"),
-                children: (element.children ?? []).map((child) => compileElement(child))
-            });
-        default: {
-            const next = (0, utils_1.clone)(element);
-            if (next.type === "group" && Array.isArray(next.children)) {
-                next.children = compileElementList(next.children);
-            }
-            return [next];
-        }
-    }
-}
-function stringProp(element, key) {
-    const value = element[key];
-    if (typeof value !== "string" || !value)
-        throw new Error(`Compound '${element.type}' requires string '${key}'.`);
-    return value;
-}
-function optionalString(element, key) {
-    const value = element[key];
-    return typeof value === "string" ? value : undefined;
-}
-function numberProp(element, key) {
-    const value = element[key];
-    if (typeof value !== "number" || !Number.isFinite(value))
-        throw new Error(`Compound '${element.type}' requires number '${key}'.`);
-    return value;
-}
-function optionalNumber(element, key) {
-    const value = element[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}

package/dist/src/deck.d.ts

@@ -1,4 +0,0 @@
-import type { ResolvedVisualDocument, VisualDocument } from "./types";
-export declare function documentForDeckStep(document: VisualDocument, sceneId: string, stepIndex: number): VisualDocument;
-export declare function resolvedFrameForDeckStep(document: VisualDocument, sceneId: string, stepIndex: number, time?: number): ResolvedVisualDocument;
-export declare function renderDeckToHtml(document: VisualDocument, sceneId: string): string;

package/dist/src/deck.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.documentForDeckStep = documentForDeckStep;
-exports.resolvedFrameForDeckStep = resolvedFrameForDeckStep;
-exports.renderDeckToHtml = renderDeckToHtml;
-const scenes_1 = require("./scenes");
-const normalize_1 = require("./normalize");
-const utils_1 = require("./utils");
-const svg_1 = require("./render/svg");
-function documentForDeckStep(document, sceneId, stepIndex) {
-    const scene = document.scenes?.[sceneId];
-    if (!scene)
-        throw new Error(`Unknown scene '${sceneId}'.`);
-    const frame = (0, scenes_1.documentForScene)(document, sceneId);
-    const activeSteps = (scene.steps ?? []).slice(0, Math.max(0, stepIndex + 1));
-    if (!activeSteps.length)
-        return frame;
-    const hidden = new Set();
-    const shown = new Set();
-    for (const step of activeSteps) {
-        for (const id of step.hide ?? [])
-            hidden.add(id);
-        for (const id of step.show ?? []) {
-            hidden.delete(id);
-            shown.add(id);
-        }
-    }
-    frame.elements = applyDeckVisibility(frame.elements ?? [], hidden, shown);
-    return frame;
-}
-function resolvedFrameForDeckStep(document, sceneId, stepIndex, time = 0) {
-    return (0, normalize_1.resolveVisualFrame)(documentForDeckStep(document, sceneId, stepIndex), time);
-}
-function renderDeckToHtml(document, sceneId) {
-    const scene = document.scenes?.[sceneId];
-    if (!scene)
-        throw new Error(`Unknown scene '${sceneId}'.`);
-    const steps = scene.steps ?? [];
-    const frameCount = Math.max(1, steps.length + 1);
-    const frames = Array.from({ length: frameCount }, (_, index) => {
-        const stepIndex = index - 1;
-        const frame = stepIndex < 0 ? (0, scenes_1.documentForScene)(document, sceneId) : documentForDeckStep(document, sceneId, stepIndex);
-        return (0, svg_1.renderToSvg)(frame);
-    });
-    const labels = ["Base", ...steps.map((step) => step.id)];
-    return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(sceneId)} Deck</title><style>
-html,body{margin:0;width:100%;height:100%;background:#111827;color:#e5e7eb;font-family:Inter,Arial,sans-serif}
-body{display:grid;grid-template-rows:1fr auto}
-main{display:grid;place-items:center;padding:24px}
-#stage svg{max-width:min(100vw,${document.canvas.width}px);max-height:calc(100vh - 112px);background:white;box-shadow:0 20px 50px rgba(0,0,0,.35)}
-footer{display:flex;align-items:center;gap:12px;padding:12px 16px;background:#020617;border-top:1px solid #1f2937}
-button{border:0;border-radius:6px;padding:8px 12px;background:#2563eb;color:#fff;font-weight:700}
-button:disabled{opacity:.45}
-code{color:#93c5fd}
-</style></head><body><main><div id="stage"></div></main><footer><button id="prev">Prev</button><button id="next">Next</button><span id="count"></span><code id="label"></code></footer><script>
-const frames=${JSON.stringify(frames)};
-const labels=${JSON.stringify(labels)};
-let index=0;
-const stage=document.getElementById("stage");
-const prev=document.getElementById("prev");
-const next=document.getElementById("next");
-const count=document.getElementById("count");
-const label=document.getElementById("label");
-function show(){
-  stage.innerHTML=frames[index];
-  prev.disabled=index===0;
-  next.disabled=index===frames.length-1;
-  count.textContent=(index+1)+" / "+frames.length;
-  label.textContent=labels[index] || "";
-}
-prev.addEventListener("click",()=>{ index=Math.max(0,index-1); show(); });
-next.addEventListener("click",()=>{ index=Math.min(frames.length-1,index+1); show(); });
-window.addEventListener("keydown",(event)=>{ if(event.key==="ArrowRight") next.click(); if(event.key==="ArrowLeft") prev.click(); });
-show();
-</script></body></html>`;
-}
-function applyDeckVisibility(elements, hidden, shown) {
-    return elements.map((element) => {
-        const next = (0, utils_1.clone)(element);
-        if (next.id && hidden.has(next.id))
-            next.opacity = 0;
-        if (next.id && shown.has(next.id) && next.opacity === 0)
-            next.opacity = 1;
-        if (next.type === "group" && Array.isArray(next.children))
-            next.children = applyDeckVisibility(next.children, hidden, shown);
-        return next;
-    });
-}
-function escapeHtml(value) {
-    return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}

package/dist/src/export/index.d.ts

@@ -1,8 +0,0 @@
-import type { ExportOptions, VisualDocument } from "../types";
-export interface ExportResult {
-    format: string;
-    content: string;
-    mimeType: string;
-    warnings?: string[];
-}
-export declare function exportVisual(document: VisualDocument, options?: ExportOptions): ExportResult;

package/dist/src/export/index.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportVisual = exportVisual;
-const html_1 = require("../render/html");
-const svg_1 = require("../render/svg");
-function exportVisual(document, options = {}) {
-    const format = options.format ?? "svg";
-    if (format === "svg") {
-        return { format, content: (0, svg_1.renderToSvg)(document, options), mimeType: "image/svg+xml" };
-    }
-    if (format === "html") {
-        return { format, content: (0, html_1.renderToHtml)(document, options), mimeType: "text/html" };
-    }
-    throw new Error(`${format.toUpperCase()} export is reserved for the advanced renderer/export adapter. The primitive JSON core currently exports svg and html directly.`);
-}

package/dist/src/kernel.d.ts

@@ -1,8 +0,0 @@
-import type { KernelVisualDocument, ResolvedVisualDocument, ValidationResult, VisualDocument } from "./types";
-import { type NormalizeOptions } from "./normalize";
-export interface LowerOptions extends NormalizeOptions {
-}
-export declare function lowerVisualDocument(document: VisualDocument, options?: LowerOptions): KernelVisualDocument;
-export declare function resolveKernelFrame(document: VisualDocument, time?: number): KernelVisualDocument;
-export declare function lowerResolvedVisualDocument(document: ResolvedVisualDocument): KernelVisualDocument;
-export declare function validateKernelVisualDocument(document: KernelVisualDocument): ValidationResult;

package/dist/src/kernel.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lowerVisualDocument = lowerVisualDocument;
-exports.resolveKernelFrame = resolveKernelFrame;
-exports.lowerResolvedVisualDocument = lowerResolvedVisualDocument;
-exports.validateKernelVisualDocument = validateKernelVisualDocument;
-const normalize_1 = require("./normalize");
-const utils_1 = require("./utils");
-const shapes_1 = require("./shapes");
-const KERNEL_2D_TYPES = new Set(["group", "path", "text", "image", "point"]);
-const KERNEL_3D_TYPES = new Set(["group3d", "mesh3d", "line3d", "text3d", "point3d", "light"]);
-function lowerVisualDocument(document, options = {}) {
-    return lowerResolvedVisualDocument((0, normalize_1.normalizeVisualDocument)(document, options));
-}
-function resolveKernelFrame(document, time = 0) {
-    return lowerResolvedVisualDocument((0, normalize_1.resolveVisualFrame)(document, time));
-}
-function lowerResolvedVisualDocument(document) {
-    return {
-        version: document.version,
-        canvas: (0, utils_1.clone)(document.canvas),
-        imports: cloneOptional(document.imports),
-        assets: cloneOptional(document.assets),
-        exports: cloneOptional(document.exports),
-        elements: lowerElements(document.elements ?? [])
-    };
-}
-function validateKernelVisualDocument(document) {
-    const issues = [];
-    const visit = (element, path) => {
-        if (!KERNEL_2D_TYPES.has(element.type) && !KERNEL_3D_TYPES.has(element.type)) {
-            issues.push({ path, code: "unsupported_kernel_type", message: `Kernel element type '${element.type}' is not supported.` });
-            return;
-        }
-        if (element.type === "path" && typeof element.d !== "string") {
-            issues.push({ path, code: "missing_kernel_path", message: "Kernel path requires string 'd'." });
-        }
-        if (element.type === "text" && (!isFiniteNumber(element.x) || !isFiniteNumber(element.y))) {
-            issues.push({ path, code: "missing_kernel_text_position", message: "Kernel text requires numeric x and y." });
-        }
-        if (element.type === "image" && (!isFiniteNumber(element.x) || !isFiniteNumber(element.y) || !isFiniteNumber(element.width) || !isFiniteNumber(element.height))) {
-            issues.push({ path, code: "missing_kernel_image_box", message: "Kernel image requires numeric x, y, width, and height." });
-        }
-        if (element.type === "point" && (!isFiniteNumber(element.x) || !isFiniteNumber(element.y))) {
-            issues.push({ path, code: "missing_kernel_point", message: "Kernel point requires numeric x and y." });
-        }
-        if (element.type === "mesh3d" && (!Array.isArray(element.vertices) || !Array.isArray(element.indices))) {
-            issues.push({ path, code: "missing_kernel_mesh", message: "Kernel mesh3d requires vertices and indices." });
-        }
-        if ((element.type === "group" || element.type === "group3d") && Array.isArray(element.children)) {
-            element.children.forEach((child, index) => visit(child, `${path}/children/${index}`));
-        }
-    };
-    (document.elements ?? []).forEach((element, index) => visit(element, `/elements/${index}`));
-    return { ok: issues.length === 0, issues, warnings: [] };
-}
-function lowerElements(elements) {
-    return elements.flatMap((element) => lowerElement(element));
-}
-function lowerElement(element) {
-    return (0, shapes_1.lowerAuthoringElement)(element, { lowerElements });
-}
-function cloneOptional(value) {
-    return value === undefined ? undefined : (0, utils_1.clone)(value);
-}
-function isFiniteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value);
-}

package/dist/src/motion.d.ts

@@ -1,4 +0,0 @@
-import type { MotionDriver, MotionExpressionInput, MotionValue, VisualDocument, VisualElement } from "./types";
-export declare function applyMotionDrivers(document: VisualDocument, time: number): VisualDocument;
-export declare function evaluateDriver(driver: MotionDriver, elements: VisualElement[], time: number): MotionValue | undefined;
-export declare function evaluateExpression(input: MotionExpressionInput, elements: VisualElement[], time: number): MotionValue;

package/dist/src/motion.js

@@ -1,262 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyMotionDrivers = applyMotionDrivers;
-exports.evaluateDriver = evaluateDriver;
-exports.evaluateExpression = evaluateExpression;
-const path_sampling_1 = require("./path-sampling");
-const shapes_1 = require("./shapes");
-const utils_1 = require("./utils");
-const utils_2 = require("./utils");
-function applyMotionDrivers(document, time) {
-    const next = (0, utils_1.clone)(document);
-    const drivers = next.motion?.drivers ?? [];
-    if (!drivers.length)
-        return next;
-    const elements = next.elements ?? [];
-    for (const driver of drivers) {
-        const value = evaluateDriver(driver, elements, time);
-        if (value !== undefined)
-            applyDriverValue(elements, driver.target, value);
-    }
-    return next;
-}
-function evaluateDriver(driver, elements, time) {
-    if (driver.expr !== undefined)
-        return evaluateExpression(driver.expr, elements, time);
-    if (Array.isArray(driver.keyframes))
-        return interpolateKeyframes(driver.keyframes, time, driver.ease);
-    return undefined;
-}
-function evaluateExpression(input, elements, time) {
-    if (typeof input === "number" || typeof input === "string" || isMotionPoint(input))
-        return (0, utils_1.clone)(input);
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        return 0;
-    switch (input.op) {
-        case "time":
-            return time;
-        case "prop":
-            return propertyValue(elements, input.target, input.property);
-        case "point": {
-            const [x, y] = input.args;
-            return [numberValue(evaluateExpression(x, elements, time)), numberValue(evaluateExpression(y, elements, time))];
-        }
-        case "add":
-            return input.args.reduce((total, item) => addValues(total, evaluateExpression(item, elements, time)), 0);
-        case "sub": {
-            const [first, ...rest] = input.args;
-            return rest.reduce((total, item) => subValues(total, evaluateExpression(item, elements, time)), evaluateExpression(first ?? 0, elements, time));
-        }
-        case "mul":
-            return input.args.reduce((total, item) => mulValues(total, evaluateExpression(item, elements, time)), 1);
-        case "div": {
-            const [first, ...rest] = input.args;
-            return rest.reduce((total, item) => divValues(total, evaluateExpression(item, elements, time)), evaluateExpression(first ?? 0, elements, time));
-        }
-        case "mod": {
-            const [left, right] = input.args;
-            const divisor = numberValue(evaluateExpression(right ?? 1, elements, time));
-            return divisor === 0 ? 0 : numberValue(evaluateExpression(left ?? 0, elements, time)) % divisor;
-        }
-        case "min":
-            return Math.min(...input.args.map((item) => numberValue(evaluateExpression(item, elements, time))));
-        case "max":
-            return Math.max(...input.args.map((item) => numberValue(evaluateExpression(item, elements, time))));
-        case "sin":
-            return Math.sin(numberValue(evaluateExpression(input.arg, elements, time)));
-        case "cos":
-            return Math.cos(numberValue(evaluateExpression(input.arg, elements, time)));
-        case "abs":
-            return absValue(evaluateExpression(input.arg, elements, time));
-        case "clamp":
-            return Math.max(numberValue(evaluateExpression(input.min, elements, time)), Math.min(numberValue(evaluateExpression(input.max, elements, time)), numberValue(evaluateExpression(input.value, elements, time))));
-        case "lerp":
-            return interpolateValue(evaluateExpression(input.from, elements, time), evaluateExpression(input.to, elements, time), numberValue(evaluateExpression(input.t, elements, time)));
-        case "bbox": {
-            const target = findElement(elements, input.target);
-            const box = target ? (0, utils_1.elementBox)(target) : undefined;
-            return box ? box[input.property] : 0;
-        }
-        case "anchor": {
-            const target = findElement(elements, input.target);
-            const box = target ? (0, utils_1.elementBox)(target) : undefined;
-            const point = box ? (0, utils_1.anchorPoint)(box, input.anchor) : [0, 0];
-            if (input.offset === undefined)
-                return point;
-            return point2Value(addValues(point, evaluateExpression(input.offset, elements, time)));
-        }
-        case "pointAt":
-            return pointOnTarget(elements, input.target, numberValue(evaluateExpression(input.progress, elements, time))) ?? [0, 0];
-        case "pathLength": {
-            const path = firstKernelPathForTarget(elements, input.target);
-            return path ? (0, path_sampling_1.pathLength)(path.d) : 0;
-        }
-        default:
-            return 0;
-    }
-}
-function interpolateKeyframes(keyframes, time, ease) {
-    const frames = keyframes
-        .filter((frame) => Array.isArray(frame) && (0, utils_1.isFiniteNumber)(frame[0]))
-        .slice()
-        .sort((left, right) => left[0] - right[0]);
-    if (!frames.length)
-        return undefined;
-    if (time <= frames[0][0])
-        return (0, utils_1.clone)(frames[0][1]);
-    for (let index = 1; index < frames.length; index += 1) {
-        const prev = frames[index - 1];
-        const next = frames[index];
-        if (time <= next[0]) {
-            const span = Math.max(0.000001, next[0] - prev[0]);
-            return interpolateValue(prev[1], next[1], (0, utils_2.easing)(ease, (time - prev[0]) / span));
-        }
-    }
-    return (0, utils_1.clone)(frames[frames.length - 1][1]);
-}
-function interpolateValue(from, to, t) {
-    const eased = Math.max(0, Math.min(1, t));
-    if (typeof from === "number" && typeof to === "number")
-        return from + (to - from) * eased;
-    if (isMotionPoint(from) && isMotionPoint(to))
-        return from.map((value, index) => value + (Number(to[index]) - value) * eased);
-    if (typeof from === "string" && typeof to === "string") {
-        const fromColor = parseHexColor(from);
-        const toColor = parseHexColor(to);
-        if (fromColor && toColor) {
-            return `#${hex(Math.round(fromColor[0] + (toColor[0] - fromColor[0]) * eased))}${hex(Math.round(fromColor[1] + (toColor[1] - fromColor[1]) * eased))}${hex(Math.round(fromColor[2] + (toColor[2] - fromColor[2]) * eased))}`;
-        }
-    }
-    return eased < 1 ? (0, utils_1.clone)(from) : (0, utils_1.clone)(to);
-}
-function applyDriverValue(elements, targetPath, value) {
-    const separator = targetPath.indexOf(".");
-    if (separator <= 0)
-        return;
-    const id = targetPath.slice(0, separator);
-    const property = targetPath.slice(separator + 1);
-    const target = findElement(elements, id);
-    if (!target)
-        return;
-    const record = target;
-    if (property === "position" && (0, utils_1.isPoint2)(value)) {
-        if ("cx" in record || target.type === "circle" || target.type === "ellipse" || target.type === "arc") {
-            record.cx = value[0];
-            record.cy = value[1];
-        }
-        else {
-            record.x = value[0];
-            record.y = value[1];
-        }
-        return;
-    }
-    record[property] = (0, utils_1.clone)(value);
-}
-function propertyValue(elements, id, property) {
-    const target = findElement(elements, id);
-    if (!target)
-        return 0;
-    const record = target;
-    if (property === "position") {
-        if ((0, utils_1.isFiniteNumber)(record.cx) && (0, utils_1.isFiniteNumber)(record.cy))
-            return [record.cx, record.cy];
-        if ((0, utils_1.isFiniteNumber)(record.x) && (0, utils_1.isFiniteNumber)(record.y))
-            return [record.x, record.y];
-    }
-    const value = record[property];
-    return typeof value === "number" || typeof value === "string" || isMotionPoint(value) ? (0, utils_1.clone)(value) : 0;
-}
-function pointOnTarget(elements, id, progress) {
-    const path = firstKernelPathForTarget(elements, id);
-    return path ? (0, path_sampling_1.pointOnPath)(path.d, progress) : undefined;
-}
-function firstKernelPathForTarget(elements, id) {
-    const target = findElement(elements, id);
-    if (!target)
-        return undefined;
-    const definition = (0, shapes_1.getInternalShapeDefinition)(target.type);
-    if (!definition?.pathQueryable)
-        return undefined;
-    const lowered = lowerFollowTarget(target);
-    return firstKernelPath(lowered);
-}
-function lowerFollowTarget(target) {
-    const lowerElements = (items) => items.flatMap((item) => (0, shapes_1.lowerAuthoringElement)(item, { lowerElements }));
-    return lowerElements([target]);
-}
-function firstKernelPath(elements) {
-    for (const element of elements) {
-        if (element.type === "path")
-            return element;
-        if ((element.type === "group" || element.type === "group3d") && Array.isArray(element.children)) {
-            const nested = firstKernelPath(element.children);
-            if (nested)
-                return nested;
-        }
-    }
-    return undefined;
-}
-function findElement(elements, id) {
-    return (0, utils_1.flattenElements)(elements).find((element) => element.id === id);
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function addValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a + b);
-    return numberValue(left) + numberValue(right);
-}
-function subValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a - b);
-    return numberValue(left) - numberValue(right);
-}
-function mulValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a * b);
-    return numberValue(left) * numberValue(right);
-}
-function divValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a / safeDenominator(b));
-    return numberValue(left) / safeDenominator(numberValue(right));
-}
-function absValue(value) {
-    if (isMotionPoint(value))
-        return value.map((item) => Math.abs(item));
-    return Math.abs(numberValue(value));
-}
-function combinePointValues(left, right, fn) {
-    const length = (isMotionPoint(left) && left.length === 3) || (isMotionPoint(right) && right.length === 3) ? 3 : 2;
-    const values = Array.from({ length }, (_, index) => fn(componentValue(left, index), componentValue(right, index)));
-    return values;
-}
-function componentValue(value, index) {
-    if (isMotionPoint(value))
-        return (0, utils_1.isFiniteNumber)(value[index]) ? value[index] : 0;
-    return numberValue(value);
-}
-function point2Value(value) {
-    if (isMotionPoint(value))
-        return [value[0], value[1]];
-    const scalar = numberValue(value);
-    return [scalar, scalar];
-}
-function safeDenominator(value) {
-    if (Math.abs(value) >= 0.000001)
-        return value;
-    return value < 0 ? -0.000001 : 0.000001;
-}
-function isMotionPoint(value) {
-    return Array.isArray(value) && (value.length === 2 || value.length === 3) && value.every((item) => typeof item === "number" && Number.isFinite(item));
-}
-function parseHexColor(value) {
-    const match = /^#([0-9a-f]{6})$/i.exec(value.trim());
-    if (!match)
-        return undefined;
-    return [parseInt(match[1].slice(0, 2), 16), parseInt(match[1].slice(2, 4), 16), parseInt(match[1].slice(4, 6), 16)];
-}
-function hex(value) {
-    return value.toString(16).padStart(2, "0");
-}

package/dist/src/patch.d.ts

@@ -1,5 +0,0 @@
-import type { VisualDocument, VisualPatchOperation } from "./types";
-export interface PatchResult {
-    document: VisualDocument;
-}
-export declare function applyVisualPatch(document: VisualDocument, operations: VisualPatchOperation | VisualPatchOperation[]): PatchResult;

package/dist/src/patch.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyVisualPatch = applyVisualPatch;
-const utils_1 = require("./utils");
-const validate_1 = require("./validate");
-function applyVisualPatch(document, operations) {
-    const ops = Array.isArray(operations) ? operations : [operations];
-    const next = (0, utils_1.clone)(document);
-    next.elements = next.elements ?? [];
-    for (const operation of ops) {
-        applyOperation(next, operation);
-    }
-    const result = (0, validate_1.validateVisualDocument)(next);
-    if (!result.ok) {
-        const first = result.issues[0];
-        throw new Error(first ? `${first.path}: ${first.message}` : "Patch produced an invalid document.");
-    }
-    return { document: next };
-}
-function applyOperation(document, operation) {
-    const elements = document.elements ?? [];
-    if (operation.op === "add") {
-        if (operation.element.id && findElement(elements, operation.element.id))
-            throw new Error(`Element '${operation.element.id}' already exists.`);
-        const index = clampIndex(operation.index ?? elements.length, elements.length);
-        elements.splice(index, 0, (0, utils_1.clone)(operation.element));
-        return;
-    }
-    const target = "id" in operation ? findElement(elements, operation.id) : undefined;
-    if (!target)
-        throw new Error(`Element '${"id" in operation ? operation.id : ""}' was not found.`);
-    if (operation.op === "update") {
-        Object.assign(target.element, (0, utils_1.clone)(operation.set));
-        return;
-    }
-    if (operation.op === "remove") {
-        target.parent.splice(target.index, 1);
-        return;
-    }
-    if (operation.op === "replace") {
-        target.parent[target.index] = (0, utils_1.clone)(operation.element);
-        return;
-    }
-    if (operation.op === "move") {
-        const record = target.element;
-        for (const key of ["x", "y", "cx", "cy"]) {
-            if (typeof operation[key] === "number")
-                record[key] = operation[key];
-        }
-        return;
-    }
-    if (operation.op === "reorder") {
-        const [item] = target.parent.splice(target.index, 1);
-        target.parent.splice(clampIndex(operation.index, target.parent.length), 0, item);
-    }
-}
-function findElement(elements, id) {
-    for (let index = 0; index < elements.length; index += 1) {
-        const element = elements[index];
-        if (element.id === id)
-            return { element, parent: elements, index };
-        if (element.type === "group" && Array.isArray(element.children)) {
-            const found = findElement(element.children, id);
-            if (found)
-                return found;
-        }
-    }
-    return undefined;
-}
-function clampIndex(index, length) {
-    return Math.max(0, Math.min(length, Math.floor(index)));
-}