@octane-xplat/smooth-corners 0.14.0 → 0.15.0

package/dist/native/packages/smooth-corners/src/apply.android.js

@@ -1,95 +0,0 @@
-import { generateCommands } from "./path.js";
-import { Color, Utils } from "@nativescript/core";
-//#region src/apply.android.ts
-/** Android smooth-corners apply — custom Drawable paints background +
-*  border along the generated path; a ViewOutlineProvider clips children
-*  (`setPath` API 30+, `setConvexPath` 21–29 for convex curves); `shadow`
-*  maps to `elevation`, which follows the outline. The `android` global is
-*  touched only inside functions so the module is import-safe on iOS. */
-var PATH_KEY = "__smoothPath";
-function toAndroidPath(cmds) {
-	const p = new android.graphics.Path();
-	for (const c of cmds) switch (c.c) {
-		case "M":
-			p.moveTo(c.x, c.y);
-			break;
-		case "L":
-			p.lineTo(c.x, c.y);
-			break;
-		case "C":
-			p.cubicTo(c.x1, c.y1, c.x2, c.y2, c.x, c.y);
-			break;
-		case "A": {
-			const rect = new android.graphics.RectF(c.cx - c.r, c.cy - c.r, c.cx + c.r, c.cy + c.r);
-			p.arcTo(rect, c.startDeg, c.sweepDeg, false);
-			break;
-		}
-		case "Z": p.close();
-	}
-	return p;
-}
-function makeDrawable(state) {
-	return android.graphics.drawable.Drawable.extend({
-		draw(canvas) {
-			const path = state.path;
-			if (!path) return;
-			const bg = state.view?.backgroundColor ?? state.view?.style?.backgroundColor;
-			const border = state.props.border;
-			if (bg) {
-				const paint = new android.graphics.Paint(android.graphics.Paint.ANTI_ALIAS_FLAG);
-				paint.setStyle(android.graphics.Paint.Style.FILL);
-				paint.setColor(new Color(bg).android);
-				canvas.drawPath(path, paint);
-			}
-			if (border && border.width > 0 && border.color) {
-				const paint = new android.graphics.Paint(android.graphics.Paint.ANTI_ALIAS_FLAG);
-				paint.setStyle(android.graphics.Paint.Style.STROKE);
-				paint.setStrokeWidth(Utils.layout.toDevicePixels(border.width) * 2);
-				paint.setColor(new Color(border.color).android);
-				canvas.drawPath(path, paint);
-			}
-		},
-		getOpacity() {
-			return android.graphics.PixelFormat.TRANSLUCENT;
-		},
-		setAlpha(_a) {},
-		setColorFilter(_f) {}
-	});
-}
-/** Clip the inner box: outline provider + background/border drawable. */
-function applySmoothClip(view, props) {
-	const s = view?.[PATH_KEY] ?? (view[PATH_KEY] = {
-		view,
-		props,
-		path: null,
-		drawable: null
-	});
-	s.props = props;
-	const v = view?.android;
-	const size = view?.getActualSize?.();
-	if (!v || !size || size.width <= 0 || size.height <= 0) return;
-	s.path = toAndroidPath(generateCommands(Utils.layout.toDevicePixels(size.width), Utils.layout.toDevicePixels(size.height), props.corners));
-	const path = s.path;
-	v.setOutlineProvider(new (android.view.ViewOutlineProvider.extend({ getOutline(target, outline) {
-		if (!path) return;
-		if (android.os.Build.VERSION.SDK_INT >= 30) outline.setPath(path);
-		else try {
-			outline.setConvexPath(path);
-		} catch {
-			outline.setRect(0, 0, target.getWidth(), target.getHeight());
-		}
-	} }))());
-	v.setClipToOutline(true);
-	if (!s.drawable) {
-		s.drawable = makeDrawable(s);
-		v.setBackground(s.drawable);
-	}
-	s.drawable.setBounds(0, 0, v.getWidth(), v.getHeight());
-	v.invalidate();
-	if (props.shadow) v.setElevation(Utils.layout.toDevicePixels(props.shadow.blur ?? 8));
-}
-/** Android needs no separate shadow layer — `elevation` follows the inner
-*  view's outline directly, so the outer hook is a no-op. */
-function applySmoothShadow(_view, _props) {}
-//#endregion
-export { applySmoothClip, applySmoothShadow };

package/dist/native/packages/smooth-corners/src/apply.ios.js

@@ -1,92 +0,0 @@
-import { generateCommands } from "./path.js";
-import { Color } from "@nativescript/core";
-//#region src/apply.ios.ts
-/** iOS smooth-corners apply — CAShapeLayer mask on the inner view,
-*  layer.shadow* on the outer. Native globals resolve lazily inside these
-*  functions so the module is import-safe on Android bundles. */
-var rad = (deg) => deg * Math.PI / 180;
-function toCGPath(cmds) {
-	const p = CGPathCreateMutable();
-	for (const c of cmds) switch (c.c) {
-		case "M":
-			CGPathMoveToPoint(p, null, c.x, c.y);
-			break;
-		case "L":
-			CGPathAddLineToPoint(p, null, c.x, c.y);
-			break;
-		case "C":
-			CGPathAddCurveToPoint(p, null, c.x1, c.y1, c.x2, c.y2, c.x, c.y);
-			break;
-		case "A":
-			CGPathAddArc(p, null, c.cx, c.cy, c.r, rad(c.startDeg), rad(c.startDeg + c.sweepDeg), c.sweepDeg < 0);
-			break;
-		case "Z": CGPathCloseSubpath(p);
-	}
-	return p;
-}
-var MASK_KEY = "__smoothMask";
-var BORDER_KEY = "__smoothBorder";
-function sizeOf(view) {
-	const size = view?.getActualSize?.();
-	return size && size.width > 0 && size.height > 0 ? {
-		w: size.width,
-		h: size.height
-	} : null;
-}
-/** Clip the inner box: layer mask + optional border stroke layer. */
-function applySmoothClip(view, props) {
-	const v = view?.ios;
-	const size = v && sizeOf(view);
-	if (!v || !size) return;
-	const path = toCGPath(generateCommands(size.w, size.h, props.corners));
-	let mask = v[MASK_KEY];
-	if (!mask) {
-		mask = CAShapeLayer.new();
-		v[MASK_KEY] = mask;
-	}
-	mask.path = path;
-	v.layer.mask = mask;
-	let borderLayer = v[BORDER_KEY];
-	const border = props.border;
-	if (border && border.width > 0 && border.color) {
-		if (!borderLayer) {
-			borderLayer = CAShapeLayer.new();
-			v[BORDER_KEY] = borderLayer;
-			v.layer.addSublayer(borderLayer);
-		}
-		borderLayer.frame = v.layer.bounds;
-		borderLayer.path = path;
-		borderLayer.fillColor = null;
-		borderLayer.strokeColor = new Color(border.color).ios.CGColor;
-		borderLayer.lineWidth = border.width * 2;
-	} else if (borderLayer) {
-		borderLayer.removeFromSuperlayer();
-		v[BORDER_KEY] = null;
-	}
-}
-/** Drop shadow on the outer view (a masked layer can't show its own). */
-function applySmoothShadow(view, props) {
-	const layer = view?.ios?.layer;
-	if (!layer) return;
-	const shadow = props.shadow;
-	if (!shadow) {
-		layer.shadowPath = null;
-		layer.shadowOpacity = 0;
-		return;
-	}
-	const size = sizeOf(view);
-	if (!size) return;
-	const spread = shadow.spread ?? 0;
-	const w = size.w + spread * 2;
-	const h = size.h + spread * 2;
-	layer.shadowPath = toCGPath(generateCommands(w, h, props.corners));
-	layer.shadowOffset = {
-		width: (shadow.offsetX ?? 0) - spread,
-		height: (shadow.offsetY ?? 0) - spread
-	};
-	layer.shadowColor = new Color(shadow.color ?? "#000000").ios.CGColor;
-	layer.shadowOpacity = shadow.opacity ?? .35;
-	layer.shadowRadius = shadow.blur ?? 0;
-}
-//#endregion
-export { applySmoothClip, applySmoothShadow };

package/dist/native/packages/smooth-corners/src/layout-child.js

@@ -1,61 +0,0 @@
-//#region src/layout-child.ts
-var OUTER_STYLE_KEYS = [
-	"width",
-	"height",
-	"margin",
-	"marginTop",
-	"marginRight",
-	"marginBottom",
-	"marginLeft"
-];
-var MARGIN_KEYS = [
-	"margin",
-	"marginTop",
-	"marginRight",
-	"marginBottom",
-	"marginLeft"
-];
-/** The inner box's `style` — everything except margins, which belong to the
-*  element's border box and move out to the wrapper. Width/height stay: the
-*  AppKit inner stack cannot stretch along its parent's main axis, so it
-*  must keep its own size. */
-function paintedStyle(style) {
-	if (!style || typeof style !== "object") return style;
-	const next = { ...style };
-	for (const key of MARGIN_KEYS) delete next[key];
-	return next;
-}
-var CHILD_PROPS_ALWAYS = [
-	"row",
-	"col",
-	"rowSpan",
-	"colSpan",
-	"left",
-	"top",
-	"horizontalAlignment",
-	"verticalAlignment",
-	"flexGrow",
-	"flexShrink",
-	"alignSelf",
-	"order"
-];
-var CHILD_PROPS_IF_SET = [
-	"dock",
-	"right",
-	"bottom"
-];
-/** Parent-layout metadata — must land on the OUTER wrapper, the node the
-*  parent layout reads as its child. Values forward under the host's own
-*  attribute names. */
-function outerLayoutProps(props) {
-	const result = {};
-	for (const key of CHILD_PROPS_ALWAYS) result[key] = props[key];
-	for (const key of CHILD_PROPS_IF_SET) if (props[key] !== void 0) result[key] = props[key];
-	const source = props.style && typeof props.style === "object" ? props.style : {};
-	const style = {};
-	for (const key of OUTER_STYLE_KEYS) if (source[key] !== void 0) style[key] = source[key];
-	result.style = Object.keys(style).length > 0 ? style : void 0;
-	return result;
-}
-//#endregion
-export { outerLayoutProps, paintedStyle };

package/dist/native/packages/smooth-corners/src/path.js

@@ -1,424 +0,0 @@
-import { a as st, i as ft, p as ot } from "../../../node_modules/.pnpm/@lisse_core@0.7.2/node_modules/@lisse/core/dist/chunk-BL6ZAFLB.js";
-//#region src/path.ts
-/** Shared smooth-corner path generation — pure TS, no DOM. Emits one
-*  `PathCommand[]` (absolute coords, arcs already center-parameterized) that
-*  web stringifies to `d`, iOS feeds `CGPathAdd*`, Android feeds
-*  `android.graphics.Path`, and macOS feeds `NSBezierPath`.
-*
-*  Lisse curves (`squircle`/`superellipse`/`clothoid`/`arc`) delegate to
-*  `@lisse/core/path`; `continuous` is our own builder — the Rosenfeld
-*  `UIBezierPath` constants reproducing Apple's fixed continuous corner
-*  (~0.25 px from SwiftUI `.continuous`; Lisse issue #103 /
-*  tools/apple-continuous-export). */
-function resolveOne(c) {
-	const cfg = typeof c === "number" ? { radius: c } : c ?? { radius: 0 };
-	return {
-		radius: cfg.radius,
-		curve: cfg.curve ?? "continuous",
-		smoothing: cfg.smoothing ?? .65,
-		exponent: cfg.exponent ?? 4,
-		preserveSmoothing: cfg.preserveSmoothing ?? true
-	};
-}
-function resolveOptions(options) {
-	if (typeof options === "number") {
-		const c = resolveOne(options);
-		return {
-			topLeft: c,
-			topRight: c,
-			bottomRight: c,
-			bottomLeft: c
-		};
-	}
-	if ("radius" in options) {
-		const c = resolveOne(options);
-		return {
-			topLeft: c,
-			topRight: c,
-			bottomRight: c,
-			bottomLeft: c
-		};
-	}
-	const p = options;
-	return {
-		topLeft: resolveOne(p.topLeft),
-		topRight: resolveOne(p.topRight),
-		bottomRight: resolveOne(p.bottomRight),
-		bottomLeft: resolveOne(p.bottomLeft)
-	};
-}
-/** Shoulder extent along each adjacent edge, as a multiple of R. */
-var CONT_P = 1.528665;
-var CONT_CURVE = [
-	[1.08849296, 0],
-	[.86840694, 0],
-	[.63149379, .07491139],
-	[.37282383, .16905956],
-	[.16905956, .37282383],
-	[.07491139, .63149379],
-	[0, .86840694],
-	[0, 1.08849296],
-	[0, 1.52866498]
-];
-var CONT_CURVE_YX = CONT_CURVE.map(([x, y]) => [y, x]);
-/** Absolute `C` commands for one continuous corner. `p` returned separately —
-*  the tangent distance from the vertex along the incoming edge. */
-function continuousCorner(w, h, radius, budget, orient) {
-	const r = Math.min(radius, budget / CONT_P);
-	const p = CONT_P * r;
-	if (r <= 0) return {
-		p: 0,
-		cmds: []
-	};
-	let fx;
-	let fy;
-	let seq = CONT_CURVE;
-	switch (orient) {
-		case "TR":
-			fx = (x, _y) => w - x * r;
-			fy = (_x, y) => y * r;
-			break;
-		case "BR":
-			fx = (x, _y) => w - x * r;
-			fy = (_x, y) => h - y * r;
-			seq = CONT_CURVE_YX;
-			break;
-		case "BL":
-			fx = (x, _y) => x * r;
-			fy = (_x, y) => h - y * r;
-			break;
-		case "TL":
-			fx = (x, _y) => x * r;
-			fy = (_x, y) => 0 + y * r;
-			seq = CONT_CURVE_YX;
-	}
-	const cmds = [];
-	for (let i = 0; i < seq.length; i += 3) {
-		const [c1, c2, e] = [
-			seq[i],
-			seq[i + 1],
-			seq[i + 2]
-		];
-		cmds.push({
-			c: "C",
-			x1: fx(c1[0], c1[1]),
-			y1: fy(c1[0], c1[1]),
-			x2: fx(c2[0], c2[1]),
-			y2: fy(c2[0], c2[1]),
-			x: fx(e[0], e[1]),
-			y: fy(e[0], e[1])
-		});
-	}
-	return {
-		p,
-		cmds
-	};
-}
-/** Parse a curve builder's per-orient relative segment starting at `pen`.
-*  Returns absolute commands. Lisse segments only emit `c`/`a`/`l`. */
-function segmentCommands(seg, pen) {
-	return parsePath(seg, pen.x, pen.y).filter((c) => c.c !== "M");
-}
-var TOKEN = /[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
-var ARITY = {
-	M: 2,
-	L: 2,
-	H: 1,
-	V: 1,
-	C: 6,
-	S: 4,
-	Q: 4,
-	T: 2,
-	A: 7,
-	Z: 0
-};
-/** Endpoint→center for a circular SVG arc (φ=0 — every Lisse emitter).
-*  Non-circular or rotated arcs throw: unsupported is loud, not silent. */
-function arcToCenter(x0, y0, rx, ry, rot, largeArc, sweep, x1, y1) {
-	if (x0 === x1 && y0 === y1) return null;
-	if (rx <= 0 || ry <= 0) return null;
-	if (rx !== ry || rot !== 0) throw new Error(`smooth-corners: only circular unrotated arcs are supported (got a ${rx} ${ry} ${rot})`);
-	const dx = (x0 - x1) / 2;
-	const dy = (y0 - y1) / 2;
-	const d2 = dx * dx + dy * dy;
-	let r = rx;
-	const lambda = d2 / (r * r);
-	if (lambda > 1) r *= Math.sqrt(lambda);
-	const h = Math.sqrt(Math.max(0, (r * r - d2) / d2));
-	const sign = largeArc !== sweep ? 1 : -1;
-	const cx = (x0 + x1) / 2 + sign * h * dy;
-	const cy = (y0 + y1) / 2 - sign * h * dx;
-	const deg = (v) => v * 180 / Math.PI;
-	const start = deg(Math.atan2(y0 - cy, x0 - cx));
-	let sweepDeg = deg(Math.atan2(y1 - cy, x1 - cx)) - start;
-	if (sweep && sweepDeg <= 0) sweepDeg += 360;
-	if (!sweep && sweepDeg >= 0) sweepDeg -= 360;
-	return {
-		c: "A",
-		cx,
-		cy,
-		r,
-		startDeg: start,
-		sweepDeg,
-		x: x1,
-		y: y1
-	};
-}
-/** Parse an SVG `d` string (or relative corner segment) into absolute
-*  `PathCommand[]`. Supports M L H V C S Q T A Z; `pen` seeds relative
-*  commands when parsing a mid-path segment. */
-function parsePath(d, penX = 0, penY = 0) {
-	const tokens = d.match(TOKEN) ?? [];
-	const out = [];
-	let i = 0;
-	let cmd = "";
-	let px = penX;
-	let py = penY;
-	let sx = penX;
-	let sy = penY;
-	const num = () => {
-		const t = tokens[i++];
-		const n = Number(t);
-		if (!Number.isFinite(n)) throw new Error(`smooth-corners: bad path token '${t}' in '${d}'`);
-		return n;
-	};
-	while (i < tokens.length) {
-		const t = tokens[i];
-		if (/[a-zA-Z]/.test(t)) {
-			cmd = t;
-			i++;
-			if (cmd === "Z" || cmd === "z") {
-				out.push({ c: "Z" });
-				px = sx;
-				py = sy;
-				continue;
-			}
-		}
-		if (!cmd) throw new Error(`smooth-corners: path data missing command: '${d}'`);
-		const rel = cmd === cmd.toLowerCase();
-		const upper = cmd.toUpperCase();
-		if (ARITY[upper] === void 0) throw new Error(`smooth-corners: unsupported path command '${cmd}'`);
-		if (upper === "S" || upper === "Q" || upper === "T") throw new Error(`smooth-corners: '${upper}' commands are not supported`);
-		switch (upper) {
-			case "M": {
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "M",
-					x,
-					y
-				});
-				px = sx = x;
-				py = sy = y;
-				cmd = rel ? "l" : "L";
-				break;
-			}
-			case "L": {
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "L",
-					x,
-					y
-				});
-				px = x;
-				py = y;
-				break;
-			}
-			case "H": {
-				const x = num() + (rel ? px : 0);
-				out.push({
-					c: "L",
-					x,
-					y: py
-				});
-				px = x;
-				break;
-			}
-			case "V": {
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "L",
-					x: px,
-					y
-				});
-				py = y;
-				break;
-			}
-			case "C": {
-				const x1 = num() + (rel ? px : 0);
-				const y1 = num() + (rel ? py : 0);
-				const x2 = num() + (rel ? px : 0);
-				const y2 = num() + (rel ? py : 0);
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "C",
-					x1,
-					y1,
-					x2,
-					y2,
-					x,
-					y
-				});
-				px = x;
-				py = y;
-				break;
-			}
-			case "A": {
-				const rx = num();
-				const ry = num();
-				const rot = num();
-				const fa = num();
-				const fs = num();
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				const arc = arcToCenter(px, py, rx, ry, rot, fa, fs, x, y);
-				if (arc) out.push(arc);
-				else out.push({
-					c: "L",
-					x,
-					y
-				});
-				px = x;
-				py = y;
-				break;
-			}
-		}
-	}
-	return out;
-}
-function lisseCornerSeg(corner, radius, budget, orient, pen) {
-	const out = ft(corner.curve)({
-		cornerRadius: radius,
-		smoothing: corner.smoothing,
-		exponent: corner.exponent,
-		preserveSmoothing: corner.preserveSmoothing,
-		roundingAndSmoothingBudget: budget
-	});
-	return {
-		p: out.p,
-		cmds: segmentCommands(out.pathSegment(orient), pen)
-	};
-}
-function cornerCmds(corner, normalized, orient, pen, w, h) {
-	if (corner.curve === "continuous") return continuousCorner(w, h, normalized.radius, normalized.roundingAndSmoothingBudget, orient);
-	return lisseCornerSeg(corner, normalized.radius, normalized.roundingAndSmoothingBudget, orient, pen);
-}
-var RECT = [
-	{
-		c: "M",
-		x: 0,
-		y: 0
-	},
-	{
-		c: "L",
-		x: 0,
-		y: 0
-	},
-	{
-		c: "L",
-		x: 0,
-		y: 0
-	},
-	{
-		c: "L",
-		x: 0,
-		y: 0
-	},
-	{ c: "Z" }
-];
-/** Absolute command list for the smooth-cornered rect. When no corner uses
-*  `continuous`, delegates to `@lisse/core` `generatePath` (keeping its
-*  capsule/blend fast paths) and parses the result; otherwise stitches
-*  per-corner segments itself (per-corner mixing with `continuous`). */
-function generateCommands(width, height, options) {
-	if (width <= 0 || height <= 0) return RECT;
-	const corners = resolveOptions(options);
-	if (!(corners.topLeft.curve === "continuous" || corners.topRight.curve === "continuous" || corners.bottomRight.curve === "continuous" || corners.bottomLeft.curve === "continuous")) return parsePath(ot(width, height, lisseOptions(corners)));
-	const normalized = st({
-		topLeftCornerRadius: corners.topLeft.radius,
-		topRightCornerRadius: corners.topRight.radius,
-		bottomRightCornerRadius: corners.bottomRight.radius,
-		bottomLeftCornerRadius: corners.bottomLeft.radius,
-		width,
-		height
-	});
-	const emit = (corner, n, orient, entryX, entryY) => cornerCmds(corner, n, orient, {
-		x: entryX,
-		y: entryY
-	}, width, height);
-	const pTL = previewP(corners.topLeft, normalized.topLeft, "TL", width, height);
-	const pTR = previewP(corners.topRight, normalized.topRight, "TR", width, height);
-	const pBR = previewP(corners.bottomRight, normalized.bottomRight, "BR", width, height);
-	const pBL = previewP(corners.bottomLeft, normalized.bottomLeft, "BL", width, height);
-	const out = [{
-		c: "M",
-		x: pTL,
-		y: 0
-	}];
-	out.push({
-		c: "L",
-		x: width - pTR,
-		y: 0
-	});
-	const tr = emit(corners.topRight, normalized.topRight, "TR", width - pTR, 0);
-	out.push(...tr.cmds);
-	out.push({
-		c: "L",
-		x: width,
-		y: height - pBR
-	});
-	const br = emit(corners.bottomRight, normalized.bottomRight, "BR", width, height - pBR);
-	out.push(...br.cmds);
-	out.push({
-		c: "L",
-		x: pBL,
-		y: height
-	});
-	const bl = emit(corners.bottomLeft, normalized.bottomLeft, "BL", pBL, height);
-	out.push(...bl.cmds);
-	out.push({
-		c: "L",
-		x: 0,
-		y: pTL
-	});
-	const tl = emit(corners.topLeft, normalized.topLeft, "TL", 0, pTL);
-	out.push(...tl.cmds);
-	out.push({ c: "Z" });
-	return out;
-}
-/** A corner's tangent distance without emitting commands (cheap for
-*  continuous; re-runs the lisse builder for other curves — called once per
-*  frame per corner, acceptable). */
-function previewP(corner, n, orient, w, h) {
-	return cornerCmds(corner, n, orient, {
-		x: 0,
-		y: 0
-	}, w, h).p;
-}
-function lisseOptions(corners) {
-	const { topLeft: a, topRight: b, bottomRight: c, bottomLeft: d } = corners;
-	if (a.radius === b.radius && a.radius === c.radius && a.radius === d.radius && a.curve === b.curve && a.curve === c.curve && a.curve === d.curve && a.smoothing === b.smoothing && a.smoothing === c.smoothing && a.smoothing === d.smoothing && a.exponent === b.exponent && a.exponent === c.exponent && a.exponent === d.exponent && a.preserveSmoothing === b.preserveSmoothing && a.preserveSmoothing === c.preserveSmoothing && a.preserveSmoothing === d.preserveSmoothing) return {
-		radius: a.radius,
-		curve: a.curve,
-		smoothing: a.smoothing,
-		exponent: a.exponent,
-		preserveSmoothing: a.preserveSmoothing
-	};
-	const per = (c) => ({
-		radius: c.radius,
-		curve: c.curve,
-		smoothing: c.smoothing,
-		exponent: c.exponent,
-		preserveSmoothing: c.preserveSmoothing
-	});
-	return {
-		topLeft: per(a),
-		topRight: per(b),
-		bottomRight: per(c),
-		bottomLeft: per(d)
-	};
-}
-//#endregion
-export { generateCommands, parsePath };

package/dist/web/index.js

@@ -1,2 +0,0 @@
-import { SmoothCorners } from "./packages/smooth-corners/src/SmoothCorners.web.tsrx.js";
-export { SmoothCorners };