@ohos-ports/html2canvas-pro 0.0.0-stage → 2.3.2-beta.0

package/dist/lib/dom/slot-cloner.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotCloner = exports.IGNORE_ATTRIBUTE = void 0;
+const node_type_guards_1 = require("./node-type-guards");
+/** Exported for reuse in document-cloner.ts */
+exports.IGNORE_ATTRIBUTE = 'data-html2canvas-ignore';
+/**
+ * Handles shadow DOM child cloning, slot assignment, and light DOM traversal.
+ * Extracted from DocumentCloner to reduce file size and improve separation of concerns.
+ */
+class SlotCloner {
+    constructor(cloneNodeFn, options, context) {
+        this.cloneNodeFn = cloneNodeFn;
+        this.options = options;
+        this.context = context;
+    }
+    appendChildNode(clone, child, copyStyles) {
+        this.safeAppendClonedChild(clone, child, copyStyles);
+    }
+    /**
+     * Clone child nodes from source element to clone element.
+     * Handles shadow DOM, slots, and light DOM appropriately.
+     */
+    cloneChildNodes(node, clone, copyStyles) {
+        if (node.shadowRoot && clone.shadowRoot) {
+            // Both original and clone have shadow roots - clone shadow DOM content
+            this.cloneShadowDOMChildren(node.shadowRoot, clone.shadowRoot, copyStyles);
+            // Also clone light DOM (slot content sources)
+            this.cloneLightDOMChildren(node, clone, copyStyles);
+        }
+        else if (node.shadowRoot && !clone.shadowRoot) {
+            // Original has shadow root but clone doesn't (creation failed)
+            // Fallback: clone shadow DOM content as light DOM to preserve content
+            this.cloneShadowDOMAsLightDOM(node.shadowRoot, clone, copyStyles);
+        }
+        else {
+            // No shadow DOM - just clone light DOM children
+            this.cloneLightDOMChildren(node, clone, copyStyles);
+        }
+    }
+    /**
+     * Check if a child node should be cloned based on filtering rules.
+     * Filters out: scripts, ignored elements, and optionally styles.
+     */
+    shouldCloneChild(child) {
+        return (!(0, node_type_guards_1.isElementNode)(child) ||
+            (!(0, node_type_guards_1.isScriptElement)(child) &&
+                !child.hasAttribute(exports.IGNORE_ATTRIBUTE) &&
+                (typeof this.options.ignoreElements !== 'function' || !this.options.ignoreElements(child))));
+    }
+    /**
+     * Check if a style element should be cloned based on copyStyles option.
+     */
+    shouldCloneStyleElement(child) {
+        return !this.options.copyStyles || !(0, node_type_guards_1.isElementNode)(child) || !(0, node_type_guards_1.isStyleElement)(child);
+    }
+    /**
+     * Safely append a cloned child to a target, applying all filtering rules.
+     */
+    safeAppendClonedChild(target, child, copyStyles) {
+        if (this.shouldCloneChild(child) && this.shouldCloneStyleElement(child)) {
+            target.appendChild(this.cloneNodeFn(child, copyStyles));
+        }
+    }
+    /**
+     * Clone assigned nodes from a slot element to the target.
+     */
+    cloneAssignedNodes(assignedNodes, target, copyStyles) {
+        assignedNodes.forEach((node) => {
+            this.safeAppendClonedChild(target, node, copyStyles);
+        });
+    }
+    /**
+     * Clone fallback content from a slot element when no nodes are assigned.
+     */
+    cloneSlotFallbackContent(slot, target, copyStyles) {
+        for (let child = slot.firstChild; child; child = child.nextSibling) {
+            this.safeAppendClonedChild(target, child, copyStyles);
+        }
+    }
+    /**
+     * Handle cloning of a slot element, including assigned nodes or fallback content.
+     */
+    cloneSlotElement(slot, targetShadowRoot, copyStyles) {
+        if (!(0, node_type_guards_1.isSlotElement)(slot)) {
+            return;
+        }
+        const slotElement = slot;
+        // Defensive check: ensure assignedNodes method exists
+        if (typeof slotElement.assignedNodes !== 'function') {
+            this.context.logger.warn('HTMLSlotElement.assignedNodes is not available', slot);
+            this.cloneSlotFallbackContent(slot, targetShadowRoot, copyStyles);
+            return;
+        }
+        const assignedNodes = slotElement.assignedNodes();
+        // Defensive check: ensure assignedNodes returns an array
+        if (!assignedNodes || !Array.isArray(assignedNodes)) {
+            this.context.logger.warn('assignedNodes() did not return a valid array', slot);
+            this.cloneSlotFallbackContent(slot, targetShadowRoot, copyStyles);
+            return;
+        }
+        if (assignedNodes.length > 0) {
+            // Clone assigned nodes
+            this.cloneAssignedNodes(assignedNodes, targetShadowRoot, copyStyles);
+        }
+        else {
+            // Clone fallback content
+            this.cloneSlotFallbackContent(slot, targetShadowRoot, copyStyles);
+        }
+    }
+    /**
+     * Clone shadow DOM children to the target shadow root.
+     */
+    cloneShadowDOMChildren(shadowRoot, targetShadowRoot, copyStyles) {
+        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {
+            if ((0, node_type_guards_1.isElementNode)(child) && (0, node_type_guards_1.isSlotElement)(child)) {
+                // Handle slot elements specially
+                this.cloneSlotElement(child, targetShadowRoot, copyStyles);
+            }
+            else {
+                // Clone regular elements
+                this.safeAppendClonedChild(targetShadowRoot, child, copyStyles);
+            }
+        }
+    }
+    /**
+     * Clone light DOM children to the target element.
+     */
+    cloneLightDOMChildren(node, clone, copyStyles) {
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            this.appendChildNode(clone, child, copyStyles);
+        }
+    }
+    /**
+     * Clone slot element as light DOM when shadow root creation failed.
+     */
+    cloneSlotElementAsLightDOM(slot, clone, copyStyles) {
+        if (!(0, node_type_guards_1.isSlotElement)(slot)) {
+            return;
+        }
+        const slotElement = slot;
+        if (typeof slotElement.assignedNodes !== 'function') {
+            // Fallback: clone slot's children
+            for (let child = slot.firstChild; child; child = child.nextSibling) {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+            return;
+        }
+        const assignedNodes = slotElement.assignedNodes();
+        if (assignedNodes && Array.isArray(assignedNodes) && assignedNodes.length > 0) {
+            // Clone assigned nodes as light DOM
+            assignedNodes.forEach((node) => this.appendChildNode(clone, node, copyStyles));
+        }
+        else {
+            // Clone fallback content as light DOM
+            for (let child = slot.firstChild; child; child = child.nextSibling) {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+        }
+    }
+    /**
+     * Clone shadow DOM content as light DOM when shadow root creation failed.
+     * This is a fallback mechanism to ensure content is not lost.
+     */
+    cloneShadowDOMAsLightDOM(shadowRoot, clone, copyStyles) {
+        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {
+            if ((0, node_type_guards_1.isElementNode)(child) && (0, node_type_guards_1.isSlotElement)(child)) {
+                this.cloneSlotElementAsLightDOM(child, clone, copyStyles);
+            }
+            else {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+        }
+    }
+}
+exports.SlotCloner = SlotCloner;

package/dist/lib/dom/text-container.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextContainer = void 0;
+const text_1 = require("../css/layout/text");
+class TextContainer {
+    constructor(context, node, styles) {
+        this.text = transform(node.data, styles.textTransform);
+        // Range offsets below are based on transformed text; keep the node in sync
+        // when casing changes string length, for example "ß".toUpperCase() === "SS".
+        if (this.text.length !== node.data.length) {
+            node.data = this.text;
+        }
+        this.textBounds = (0, text_1.parseTextBounds)(context, this.text, styles, node);
+    }
+}
+exports.TextContainer = TextContainer;
+const transform = (text, transform) => {
+    switch (transform) {
+        case 1 /* TEXT_TRANSFORM.LOWERCASE */:
+            return text.toLowerCase();
+        case 3 /* TEXT_TRANSFORM.CAPITALIZE */:
+            return text.replace(CAPITALIZE, capitalize);
+        case 2 /* TEXT_TRANSFORM.UPPERCASE */:
+            return text.toUpperCase();
+        default:
+            return text;
+    }
+};
+const CAPITALIZE = /(^|\s|:|-|\(|\))([a-z])/g;
+const capitalize = (m, p1, p2) => {
+    if (m.length > 0) {
+        return p1 + p2.toUpperCase();
+    }
+    return m;
+};

package/dist/lib/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMonitor = exports.createDefaultValidator = exports.Validator = exports.Html2CanvasConfig = exports.html2canvas = void 0;
+const config_1 = require("./config");
+Object.defineProperty(exports, "Html2CanvasConfig", { enumerable: true, get: function () { return config_1.Html2CanvasConfig; } });
+const validator_1 = require("./core/validator");
+Object.defineProperty(exports, "createDefaultValidator", { enumerable: true, get: function () { return validator_1.createDefaultValidator; } });
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validator_1.Validator; } });
+const performance_monitor_1 = require("./core/performance-monitor");
+Object.defineProperty(exports, "PerformanceMonitor", { enumerable: true, get: function () { return performance_monitor_1.PerformanceMonitor; } });
+const render_element_1 = require("./core/render-element");
+/**
+ * Renders an HTML element to a `<canvas>` element.
+ *
+ * The function clones the target element and its subtree into a hidden iframe,
+ * resolves all computed styles, and paints the result onto a canvas —
+ * producing a visual snapshot of the DOM as it appears in the browser.
+ *
+ * @example
+ * ```ts
+ * import html2canvas from 'html2canvas-pro';
+ *
+ * const canvas = await html2canvas(document.body, {
+ *   backgroundColor: '#ffffff',
+ *   scale: 2,
+ *   useCORS: true
+ * });
+ * document.body.appendChild(canvas);
+ * ```
+ *
+ * @param element - The root HTMLElement to render.
+ * @param options - Rendering options.
+ * @param config  - Advanced configuration. In most cases this is auto-created;
+ *                  only pass it if you need to share a cache across multiple calls.
+ * @returns A promise that resolves to the rendered HTMLCanvasElement.
+ *
+ * @throws {Error} If the element is not attached to a document.
+ * @throws {DOMException} If an {@link Options.signal|AbortSignal} was provided and the operation was aborted.
+ */
+const html2canvas = (element, options = {}, config) => {
+    const finalConfig = config ||
+        config_1.Html2CanvasConfig.fromElement(element, {
+            cspNonce: options.cspNonce,
+            cache: options.cache
+        });
+    return (0, render_element_1.renderElement)(element, options, finalConfig);
+};
+exports.html2canvas = html2canvas;
+exports.default = html2canvas;

package/dist/lib/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/render/background.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBackgroundRepeatPath = exports.getBackgroundValueForIndex = exports.calculateBackgroundSize = exports.isAuto = exports.calculateBackgroundRendering = exports.calculateBackgroundPaintingArea = exports.calculateBackgroundPositioningArea = void 0;
+const background_size_1 = require("../css/property-descriptors/background-size");
+const vector_1 = require("./vector");
+const length_percentage_1 = require("../css/types/length-percentage");
+const parser_1 = require("../css/syntax/parser");
+const box_sizing_1 = require("./box-sizing");
+const calculateBackgroundPositioningArea = (backgroundOrigin, element) => {
+    if (backgroundOrigin === 0 /* BACKGROUND_ORIGIN.BORDER_BOX */) {
+        return element.bounds;
+    }
+    if (backgroundOrigin === 2 /* BACKGROUND_ORIGIN.CONTENT_BOX */) {
+        return (0, box_sizing_1.contentBox)(element);
+    }
+    return (0, box_sizing_1.paddingBox)(element);
+};
+exports.calculateBackgroundPositioningArea = calculateBackgroundPositioningArea;
+const calculateBackgroundPaintingArea = (backgroundClip, element) => {
+    if (backgroundClip === 0 /* BACKGROUND_CLIP.BORDER_BOX */) {
+        return element.bounds;
+    }
+    if (backgroundClip === 2 /* BACKGROUND_CLIP.CONTENT_BOX */) {
+        return (0, box_sizing_1.contentBox)(element);
+    }
+    return (0, box_sizing_1.paddingBox)(element);
+};
+exports.calculateBackgroundPaintingArea = calculateBackgroundPaintingArea;
+const calculateBackgroundRendering = (container, index, intrinsicSize) => {
+    const backgroundPositioningArea = (0, exports.calculateBackgroundPositioningArea)((0, exports.getBackgroundValueForIndex)(container.styles.backgroundOrigin, index), container);
+    const backgroundPaintingArea = (0, exports.calculateBackgroundPaintingArea)((0, exports.getBackgroundValueForIndex)(container.styles.backgroundClip, index), container);
+    const backgroundImageSize = (0, exports.calculateBackgroundSize)((0, exports.getBackgroundValueForIndex)(container.styles.backgroundSize, index), intrinsicSize, backgroundPositioningArea);
+    let [sizeWidth, sizeHeight] = backgroundImageSize;
+    const position = (0, length_percentage_1.getAbsoluteValueForTuple)((0, exports.getBackgroundValueForIndex)(container.styles.backgroundPosition, index), backgroundPositioningArea.width - sizeWidth, backgroundPositioningArea.height - sizeHeight);
+    const path = (0, exports.calculateBackgroundRepeatPath)((0, exports.getBackgroundValueForIndex)(container.styles.backgroundRepeat, index), position, backgroundImageSize, backgroundPositioningArea, backgroundPaintingArea);
+    const offsetX = Math.round(backgroundPositioningArea.left + position[0]);
+    const offsetY = Math.round(backgroundPositioningArea.top + position[1]);
+    sizeWidth = Math.max(1, sizeWidth);
+    sizeHeight = Math.max(1, sizeHeight);
+    return [path, offsetX, offsetY, sizeWidth, sizeHeight];
+};
+exports.calculateBackgroundRendering = calculateBackgroundRendering;
+const isAuto = (token) => (0, parser_1.isIdentToken)(token) && token.value === background_size_1.BACKGROUND_SIZE.AUTO;
+exports.isAuto = isAuto;
+const hasIntrinsicValue = (value) => typeof value === 'number';
+const calculateBackgroundSize = (size, [intrinsicWidth, intrinsicHeight, intrinsicProportion], bounds) => {
+    const [first, second] = size;
+    if (!first) {
+        return [0, 0];
+    }
+    if ((0, length_percentage_1.isLengthPercentage)(first) && second && (0, length_percentage_1.isLengthPercentage)(second)) {
+        return [(0, length_percentage_1.getAbsoluteValue)(first, bounds.width), (0, length_percentage_1.getAbsoluteValue)(second, bounds.height)];
+    }
+    const hasIntrinsicProportion = hasIntrinsicValue(intrinsicProportion);
+    if ((0, parser_1.isIdentToken)(first) && (first.value === background_size_1.BACKGROUND_SIZE.CONTAIN || first.value === background_size_1.BACKGROUND_SIZE.COVER)) {
+        if (hasIntrinsicValue(intrinsicProportion)) {
+            const targetRatio = bounds.width / bounds.height;
+            return targetRatio < intrinsicProportion !== (first.value === background_size_1.BACKGROUND_SIZE.COVER)
+                ? [bounds.width, bounds.width / intrinsicProportion]
+                : [bounds.height * intrinsicProportion, bounds.height];
+        }
+        return [bounds.width, bounds.height];
+    }
+    const hasIntrinsicWidth = hasIntrinsicValue(intrinsicWidth);
+    const hasIntrinsicHeight = hasIntrinsicValue(intrinsicHeight);
+    const hasIntrinsicDimensions = hasIntrinsicWidth || hasIntrinsicHeight;
+    // If the background-size is auto or auto auto:
+    if ((0, exports.isAuto)(first) && (!second || (0, exports.isAuto)(second))) {
+        // If the image has both horizontal and vertical intrinsic dimensions, it's rendered at that size.
+        if (hasIntrinsicWidth && hasIntrinsicHeight) {
+            return [intrinsicWidth, intrinsicHeight];
+        }
+        // If the image has no intrinsic dimensions and has no intrinsic proportions,
+        // it's rendered at the size of the background positioning area.
+        if (!hasIntrinsicProportion && !hasIntrinsicDimensions) {
+            return [bounds.width, bounds.height];
+        }
+        // NOTE (known gap): Per the CSS spec, images with intrinsic proportions
+        // but no intrinsic dimensions should be rendered as if 'contain' had been
+        // specified. This branch is not yet implemented — the image will render
+        // at the size of the background positioning area instead.
+        // If the image has only one intrinsic dimension and has intrinsic proportions, it's rendered at the size corresponding to that one dimension.
+        // The other dimension is computed using the specified dimension and the intrinsic proportions.
+        if (hasIntrinsicDimensions && hasIntrinsicProportion) {
+            const width = hasIntrinsicWidth
+                ? intrinsicWidth
+                : intrinsicHeight * intrinsicProportion;
+            const height = hasIntrinsicHeight
+                ? intrinsicHeight
+                : intrinsicWidth / intrinsicProportion;
+            return [width, height];
+        }
+        // If the image has only one intrinsic dimension but has no intrinsic proportions,
+        // it's rendered using the specified dimension and the other dimension of the background positioning area.
+        const width = hasIntrinsicWidth ? intrinsicWidth : bounds.width;
+        const height = hasIntrinsicHeight ? intrinsicHeight : bounds.height;
+        return [width, height];
+    }
+    // If the image has intrinsic proportions, it's stretched to the specified dimension.
+    // The unspecified dimension is computed using the specified dimension and the intrinsic proportions.
+    if (hasIntrinsicProportion) {
+        let width = 0;
+        let height = 0;
+        if ((0, length_percentage_1.isLengthPercentage)(first)) {
+            width = (0, length_percentage_1.getAbsoluteValue)(first, bounds.width);
+        }
+        else if ((0, length_percentage_1.isLengthPercentage)(second)) {
+            height = (0, length_percentage_1.getAbsoluteValue)(second, bounds.height);
+        }
+        if ((0, exports.isAuto)(first)) {
+            width = height * intrinsicProportion;
+        }
+        else if (!second || (0, exports.isAuto)(second)) {
+            height = width / intrinsicProportion;
+        }
+        return [width, height];
+    }
+    // If the image has no intrinsic proportions, it's stretched to the specified dimension.
+    // The unspecified dimension is computed using the image's corresponding intrinsic dimension,
+    // if there is one. If there is no such intrinsic dimension,
+    // it becomes the corresponding dimension of the background positioning area.
+    let width = null;
+    let height = null;
+    if ((0, length_percentage_1.isLengthPercentage)(first)) {
+        width = (0, length_percentage_1.getAbsoluteValue)(first, bounds.width);
+    }
+    else if (second && (0, length_percentage_1.isLengthPercentage)(second)) {
+        height = (0, length_percentage_1.getAbsoluteValue)(second, bounds.height);
+    }
+    if (width !== null && (!second || (0, exports.isAuto)(second))) {
+        height =
+            hasIntrinsicWidth && hasIntrinsicHeight
+                ? (width / intrinsicWidth) * intrinsicHeight
+                : bounds.height;
+    }
+    if (height !== null && (0, exports.isAuto)(first)) {
+        width =
+            hasIntrinsicWidth && hasIntrinsicHeight
+                ? (height / intrinsicHeight) * intrinsicWidth
+                : bounds.width;
+    }
+    if (width !== null && height !== null) {
+        return [width, height];
+    }
+    throw new Error(`Unable to calculate background-size for element`);
+};
+exports.calculateBackgroundSize = calculateBackgroundSize;
+const getBackgroundValueForIndex = (values, index) => {
+    const value = values[index];
+    if (typeof value === 'undefined') {
+        return values[0];
+    }
+    return value;
+};
+exports.getBackgroundValueForIndex = getBackgroundValueForIndex;
+const calculateBackgroundRepeatPath = (repeat, [x, y], [width, height], backgroundPositioningArea, backgroundPaintingArea) => {
+    switch (repeat) {
+        case 2 /* BACKGROUND_REPEAT.REPEAT_X */:
+            return [
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left), Math.round(backgroundPositioningArea.top + y)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + backgroundPositioningArea.width), Math.round(backgroundPositioningArea.top + y)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + backgroundPositioningArea.width), Math.round(height + backgroundPositioningArea.top + y)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left), Math.round(height + backgroundPositioningArea.top + y))
+            ];
+        case 3 /* BACKGROUND_REPEAT.REPEAT_Y */:
+            return [
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.top)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.top)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.height + backgroundPositioningArea.top)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.height + backgroundPositioningArea.top))
+            ];
+        case 1 /* BACKGROUND_REPEAT.NO_REPEAT */:
+            return [
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.top + y)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.top + y)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.top + y + height)),
+                new vector_1.Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.top + y + height))
+            ];
+        default:
+            return [
+                new vector_1.Vector(Math.round(backgroundPaintingArea.left), Math.round(backgroundPaintingArea.top)),
+                new vector_1.Vector(Math.round(backgroundPaintingArea.left + backgroundPaintingArea.width), Math.round(backgroundPaintingArea.top)),
+                new vector_1.Vector(Math.round(backgroundPaintingArea.left + backgroundPaintingArea.width), Math.round(backgroundPaintingArea.height + backgroundPaintingArea.top)),
+                new vector_1.Vector(Math.round(backgroundPaintingArea.left), Math.round(backgroundPaintingArea.height + backgroundPaintingArea.top))
+            ];
+    }
+};
+exports.calculateBackgroundRepeatPath = calculateBackgroundRepeatPath;

package/dist/lib/render/bezier-curve.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBezierCurve = exports.BezierCurve = void 0;
+const vector_1 = require("./vector");
+const lerp = (a, b, t) => {
+    return new vector_1.Vector(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+};
+class BezierCurve {
+    constructor(start, startControl, endControl, end) {
+        this.type = 1 /* PathType.BEZIER_CURVE */;
+        this.start = start;
+        this.startControl = startControl;
+        this.endControl = endControl;
+        this.end = end;
+    }
+    subdivide(t, firstHalf) {
+        const ab = lerp(this.start, this.startControl, t);
+        const bc = lerp(this.startControl, this.endControl, t);
+        const cd = lerp(this.endControl, this.end, t);
+        const abbc = lerp(ab, bc, t);
+        const bccd = lerp(bc, cd, t);
+        const dest = lerp(abbc, bccd, t);
+        return firstHalf ? new BezierCurve(this.start, ab, abbc, dest) : new BezierCurve(dest, bccd, cd, this.end);
+    }
+    add(deltaX, deltaY) {
+        return new BezierCurve(this.start.add(deltaX, deltaY), this.startControl.add(deltaX, deltaY), this.endControl.add(deltaX, deltaY), this.end.add(deltaX, deltaY));
+    }
+    reverse() {
+        return new BezierCurve(this.end, this.endControl, this.startControl, this.start);
+    }
+}
+exports.BezierCurve = BezierCurve;
+const isBezierCurve = (path) => path.type === 1 /* PathType.BEZIER_CURVE */;
+exports.isBezierCurve = isBezierCurve;

package/dist/lib/render/border.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePathForBorderStroke = exports.parsePathForBorderDoubleInner = exports.parsePathForBorderDoubleOuter = exports.parsePathForBorder = void 0;
+const bezier_curve_1 = require("./bezier-curve");
+const parsePathForBorder = (curves, borderSide) => {
+    switch (borderSide) {
+        case 0:
+            return createPathFromCurves(curves.topLeftBorderBox, curves.topLeftPaddingBox, curves.topRightBorderBox, curves.topRightPaddingBox);
+        case 1:
+            return createPathFromCurves(curves.topRightBorderBox, curves.topRightPaddingBox, curves.bottomRightBorderBox, curves.bottomRightPaddingBox);
+        case 2:
+            return createPathFromCurves(curves.bottomRightBorderBox, curves.bottomRightPaddingBox, curves.bottomLeftBorderBox, curves.bottomLeftPaddingBox);
+        case 3:
+        default:
+            return createPathFromCurves(curves.bottomLeftBorderBox, curves.bottomLeftPaddingBox, curves.topLeftBorderBox, curves.topLeftPaddingBox);
+    }
+};
+exports.parsePathForBorder = parsePathForBorder;
+const parsePathForBorderDoubleOuter = (curves, borderSide) => {
+    switch (borderSide) {
+        case 0:
+            return createPathFromCurves(curves.topLeftBorderBox, curves.topLeftBorderDoubleOuterBox, curves.topRightBorderBox, curves.topRightBorderDoubleOuterBox);
+        case 1:
+            return createPathFromCurves(curves.topRightBorderBox, curves.topRightBorderDoubleOuterBox, curves.bottomRightBorderBox, curves.bottomRightBorderDoubleOuterBox);
+        case 2:
+            return createPathFromCurves(curves.bottomRightBorderBox, curves.bottomRightBorderDoubleOuterBox, curves.bottomLeftBorderBox, curves.bottomLeftBorderDoubleOuterBox);
+        case 3:
+        default:
+            return createPathFromCurves(curves.bottomLeftBorderBox, curves.bottomLeftBorderDoubleOuterBox, curves.topLeftBorderBox, curves.topLeftBorderDoubleOuterBox);
+    }
+};
+exports.parsePathForBorderDoubleOuter = parsePathForBorderDoubleOuter;
+const parsePathForBorderDoubleInner = (curves, borderSide) => {
+    switch (borderSide) {
+        case 0:
+            return createPathFromCurves(curves.topLeftBorderDoubleInnerBox, curves.topLeftPaddingBox, curves.topRightBorderDoubleInnerBox, curves.topRightPaddingBox);
+        case 1:
+            return createPathFromCurves(curves.topRightBorderDoubleInnerBox, curves.topRightPaddingBox, curves.bottomRightBorderDoubleInnerBox, curves.bottomRightPaddingBox);
+        case 2:
+            return createPathFromCurves(curves.bottomRightBorderDoubleInnerBox, curves.bottomRightPaddingBox, curves.bottomLeftBorderDoubleInnerBox, curves.bottomLeftPaddingBox);
+        case 3:
+        default:
+            return createPathFromCurves(curves.bottomLeftBorderDoubleInnerBox, curves.bottomLeftPaddingBox, curves.topLeftBorderDoubleInnerBox, curves.topLeftPaddingBox);
+    }
+};
+exports.parsePathForBorderDoubleInner = parsePathForBorderDoubleInner;
+const parsePathForBorderStroke = (curves, borderSide) => {
+    switch (borderSide) {
+        case 0:
+            return createStrokePathFromCurves(curves.topLeftBorderStroke, curves.topRightBorderStroke);
+        case 1:
+            return createStrokePathFromCurves(curves.topRightBorderStroke, curves.bottomRightBorderStroke);
+        case 2:
+            return createStrokePathFromCurves(curves.bottomRightBorderStroke, curves.bottomLeftBorderStroke);
+        case 3:
+        default:
+            return createStrokePathFromCurves(curves.bottomLeftBorderStroke, curves.topLeftBorderStroke);
+    }
+};
+exports.parsePathForBorderStroke = parsePathForBorderStroke;
+const createStrokePathFromCurves = (outer1, outer2) => {
+    const path = [];
+    if ((0, bezier_curve_1.isBezierCurve)(outer1)) {
+        path.push(outer1.subdivide(0.5, false));
+    }
+    else {
+        path.push(outer1);
+    }
+    if ((0, bezier_curve_1.isBezierCurve)(outer2)) {
+        path.push(outer2.subdivide(0.5, true));
+    }
+    else {
+        path.push(outer2);
+    }
+    return path;
+};
+const createPathFromCurves = (outer1, inner1, outer2, inner2) => {
+    const path = [];
+    if ((0, bezier_curve_1.isBezierCurve)(outer1)) {
+        path.push(outer1.subdivide(0.5, false));
+    }
+    else {
+        path.push(outer1);
+    }
+    if ((0, bezier_curve_1.isBezierCurve)(outer2)) {
+        path.push(outer2.subdivide(0.5, true));
+    }
+    else {
+        path.push(outer2);
+    }
+    if ((0, bezier_curve_1.isBezierCurve)(inner2)) {
+        path.push(inner2.subdivide(0.5, true).reverse());
+    }
+    else {
+        path.push(inner2);
+    }
+    if ((0, bezier_curve_1.isBezierCurve)(inner1)) {
+        path.push(inner1.subdivide(0.5, false).reverse());
+    }
+    else {
+        path.push(inner1);
+    }
+    return path;
+};