@pixelium/web-vue 0.0.2 → 0.0.3-alpha

package/es/share/util/plot.js

@@ -1,249 +1,477 @@
-import { $, k } from "../../aside/index.js";
-import { f as fillArr, c as clamp } from "./common.js";
-import { i as inBrowser } from "./env.js";
+import { D as S, P as ke, g as A } from "../../vendor.js";
+import { n as fillArr } from "./common.js";
+import { t as inBrowser } from "./env.js";
+import { a as MEDIUM_BASE_SIZE, i as LARGE_BASE_SIZE, o as SMALL_BASE_SIZE } from "../const/style.js";
+const roundToPixel = (coord, pixelSize) => Math.floor(coord / pixelSize) * pixelSize;
 function shouldPlot(x, y, startRad, endRad) {
-  let currentAngle = Math.atan2(y, x);
-  if (currentAngle < 0) {
-    currentAngle += Math.PI * 2;
-  }
-  return currentAngle >= startRad && currentAngle <= endRad;
+	let currentAngle = Math.atan2(y, x);
+	if (currentAngle < 0) currentAngle += Math.PI * 2;
+	if (!(currentAngle >= startRad && currentAngle <= endRad)) return false;
+	return true;
 }
+var QUADRANT_TEMPLATES = [
+	[1, 1],
+	[-1, 1],
+	[1, -1],
+	[-1, -1],
+	[1, 1],
+	[-1, 1],
+	[1, -1],
+	[-1, -1]
+];
 function plot(ctx, x, y, centerX, centerY, startRad, endRad, pixelSize) {
-  const quadrants = [
-    [x, y],
-    [-x, y],
-    [x, -y],
-    [-x, -y],
-    [y, x],
-    [-y, x],
-    [y, -x],
-    [-y, -x]
-  ];
-  for (const [px, py] of quadrants) {
-    if (shouldPlot(px, py, startRad, endRad)) {
-      ctx.fillRect(centerX + px, centerY + py, pixelSize, pixelSize);
-    }
-  }
+	const xRound = x;
+	const yRound = y;
+	for (let i = 0; i < QUADRANT_TEMPLATES.length; i++) {
+		const [sign1, sign2] = QUADRANT_TEMPLATES[i];
+		let px, py;
+		if (i < 4) {
+			px = sign1 * xRound;
+			py = sign2 * yRound;
+		} else {
+			px = sign1 * yRound;
+			py = sign2 * xRound;
+		}
+		if (shouldPlot(px, py, startRad, endRad)) ctx.fillRect(centerX + px, centerY + py, pixelSize, pixelSize);
+	}
 }
 function drawCircle(ctx, centerX, centerY, radius, startRad = 0, endRad = Math.PI * 2, pixelSize) {
-  let x = 0;
-  let y = radius;
-  let d = 3 - 2 * radius;
-  while (x <= y + pixelSize) {
-    plot(ctx, x, y, centerX, centerY, startRad, endRad, pixelSize);
-    x += pixelSize;
-    if (d > 0) {
-      y -= pixelSize;
-      d += 4 * (x - y) + 10;
-    } else {
-      d += 4 * x + 6;
-    }
-  }
+	let s = pixelSize;
+	if (s <= 0 || radius <= 0) return;
+	let rate = radius / s;
+	let x = 0;
+	let y = radius;
+	const dy = s;
+	const tmp = radius / 2 * Math.SQRT2;
+	const end = Math.ceil(tmp);
+	const dx = s;
+	while (x <= end) {
+		plot(ctx, x, y, centerX, centerY, startRad, endRad, s);
+		x += dx;
+		const yP = radius * radius - x * x;
+		const originalY = y;
+		if ((y - dy / 2) * (y - dy / 2) > yP) y -= dy;
+		if (x >= end && originalY === y) break;
+	}
+	if (rate > 6 && rate < 7) {
+		const fix = Math.round(tmp);
+		plot(ctx, fix, fix, centerX, centerY, startRad, endRad, s);
+	}
+}
+function drawSmoothCircle(ctx, centerX, centerY, radius, startRad = 0, endRad = Math.PI * 2, pixelSize) {
+	let s = pixelSize;
+	if (s <= 0 || radius <= 0) return;
+	const rate = radius / s;
+	let x = 0;
+	let y = radius;
+	let dy = rate < 4 ? Math.round(s / 2) : rate < 6 ? Math.round(s / 8 * 3) : rate < 8 ? Math.round(s / 8 * 5) : s;
+	dy = Math.max(dy, 1);
+	const tmp = radius / 2 * Math.SQRT2;
+	const end = Math.ceil(tmp);
+	const dx = rate < 4 ? s / 4 * 3 : s;
+	while (x <= end) {
+		plot(ctx, Math.floor(x), Math.floor(y), centerX, centerY, startRad, endRad, s);
+		x += dx;
+		const yP = radius * radius - x * x;
+		const originalY = y;
+		while (Math.abs(y * y - yP) >= Math.abs((y - dy) * (y - dy) - yP)) y -= dy;
+		if (x >= end && originalY === y) {
+			y -= dy;
+			break;
+		}
+	}
 }
 function floodFill(ctx, startX, startY, fillColor) {
-  const w = ctx.canvas.width;
-  const h = ctx.canvas.height;
-  if (w <= 0 || h <= 0) {
-    return;
-  }
-  const img = ctx.getImageData(0, 0, w, h);
-  const data32 = new Uint32Array(img.data.buffer);
-  const uint32Color = fillColor.a << 24 | fillColor.b << 16 | fillColor.g << 8 | fillColor.r;
-  const startPos = startY * w + startX;
-  const targetColor = data32[startPos];
-  if (targetColor === uint32Color) return;
-  const stack = [];
-  const firstSpan = fillLine(startX, startY, 1);
-  if (firstSpan) stack.push({ ...firstSpan, dy: 1 });
-  const secondSpan = fillLine(startX, startY - 1, -1);
-  if (secondSpan) stack.push({ ...secondSpan, dy: -1 });
-  while (stack.length) {
-    const { y, left, right, dy } = stack.pop();
-    const ny = y + dy;
-    if (ny < 0 || ny >= h) continue;
-    let x = left;
-    while (x <= right) {
-      while (x <= right && data32[ny * w + x] !== targetColor) x++;
-      if (x > right) break;
-      const spanLeft = x;
-      const newSpan = fillLine(spanLeft, ny, dy);
-      if (newSpan) stack.push(newSpan);
-      x = newSpan ? newSpan.right + 1 : spanLeft + 1;
-    }
-  }
-  ctx.putImageData(img, 0, 0);
-  function fillLine(x, y, dy) {
-    let left = x;
-    while (left > 0 && data32[y * w + left - 1] === targetColor) left--;
-    let right = x;
-    while (right < w - 1 && data32[y * w + right + 1] === targetColor) right++;
-    for (let i = left; i <= right; i++) data32[y * w + i] = uint32Color;
-    return { y, left, right, dy };
-  }
+	const w = ctx.canvas.width;
+	const h = ctx.canvas.height;
+	if (w <= 0 || h <= 0) return;
+	const img = ctx.getImageData(0, 0, w, h);
+	const data32 = new Uint32Array(img.data.buffer);
+	const uint32Color = fillColor.a << 24 | fillColor.b << 16 | fillColor.g << 8 | fillColor.r;
+	const targetColor = data32[startY * w + startX];
+	if (targetColor === uint32Color) return;
+	const stack = [];
+	const firstSpan = fillLine(startX, startY, 1);
+	if (firstSpan) stack.push({
+		...firstSpan,
+		dy: 1
+	});
+	const secondSpan = fillLine(startX, startY - 1, -1);
+	if (secondSpan) stack.push({
+		...secondSpan,
+		dy: -1
+	});
+	while (stack.length) {
+		const { y, left, right, dy } = stack.pop();
+		const ny = y + dy;
+		if (ny < 0 || ny >= h) continue;
+		let x = left;
+		while (x <= right) {
+			while (x <= right && data32[ny * w + x] !== targetColor) x++;
+			if (x > right) break;
+			const spanLeft = x;
+			const newSpan = fillLine(spanLeft, ny, dy);
+			if (newSpan) stack.push(newSpan);
+			x = newSpan ? newSpan.right + 1 : spanLeft + 1;
+		}
+	}
+	ctx.putImageData(img, 0, 0);
+	function fillLine(x, y, dy) {
+		let left = x;
+		while (left > 0 && data32[y * w + left - 1] === targetColor) left--;
+		let right = x;
+		while (right < w - 1 && data32[y * w + right + 1] === targetColor) right++;
+		for (let i = left; i <= right; i++) data32[y * w + i] = uint32Color;
+		return {
+			y,
+			left,
+			right,
+			dy
+		};
+	}
 }
-const transformBorderRadiusSizeValue = (canvas, value, pixelSize) => {
-  if (k(value)) {
-    return Math.max(value, pixelSize);
-  } else {
-    return Math.max(canvas.height * parseFloat(value) / 100, pixelSize);
-  }
+const transformBorderRadiusSizeValue = (canvas, value, pixelSize, direction = "horizontal") => {
+	if (A(value)) return Math.max(value, pixelSize);
+	else return Math.max((direction === "horizontal" ? canvas.height : canvas.width) * parseFloat(value) / 100, pixelSize);
+};
+var getRadiusFromValue = (canvas, value, pixelSize, direction = "horizontal") => {
+	if (!value) return fillArr(pixelSize, 4);
+	if (!S(value)) return fillArr(transformBorderRadiusSizeValue(canvas, value, pixelSize, direction), 4);
+	switch (value.length) {
+		case 1: return fillArr(transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction), 4);
+		case 2: {
+			const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction);
+			const tr = transformBorderRadiusSizeValue(canvas, value[1], pixelSize, direction);
+			return [
+				tl,
+				tr,
+				tl,
+				tr
+			];
+		}
+		case 3: {
+			const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction);
+			const br = transformBorderRadiusSizeValue(canvas, value[2], pixelSize, direction);
+			const rest = transformBorderRadiusSizeValue(canvas, value[1], pixelSize, direction);
+			return [
+				tl,
+				rest,
+				br,
+				rest
+			];
+		}
+		default: return value.map((e) => transformBorderRadiusSizeValue(canvas, e, pixelSize, direction));
+	}
 };
-const getRadiusFromValue = (canvas, value, pixelSize) => {
-  if (!value) return fillArr(pixelSize, 4);
-  if (!$(value)) {
-    return fillArr(transformBorderRadiusSizeValue(canvas, value, pixelSize), 4);
-  }
-  switch (value.length) {
-    case 1:
-      return fillArr(transformBorderRadiusSizeValue(canvas, value[0], pixelSize), 4);
-    case 2: {
-      const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize);
-      const tr = transformBorderRadiusSizeValue(canvas, value[1], pixelSize);
-      return [tl, tr, tl, tr];
-    }
-    case 3: {
-      const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize);
-      const br = transformBorderRadiusSizeValue(canvas, value[2], pixelSize);
-      const rest = transformBorderRadiusSizeValue(canvas, value[1], pixelSize);
-      return [tl, rest, br, rest];
-    }
-    default:
-      return value.map((e) => transformBorderRadiusSizeValue(canvas, e, pixelSize));
-  }
+var getInnerRadius = (canvas, value, pixelSize, first, last, direction = "horizontal") => {
+	if (!value) return fillArr(pixelSize, 4);
+	if (!S(value)) {
+		const v = transformBorderRadiusSizeValue(canvas, value, pixelSize, direction);
+		if (last) return [
+			pixelSize,
+			v,
+			v,
+			pixelSize
+		];
+		if (first) return [
+			v,
+			pixelSize,
+			pixelSize,
+			v
+		];
+		return fillArr(pixelSize, 4);
+	}
+	switch (value.length) {
+		case 1:
+			const v = transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction);
+			if (last) return [
+				pixelSize,
+				v,
+				v,
+				pixelSize
+			];
+			if (first) return [
+				v,
+				pixelSize,
+				pixelSize,
+				v
+			];
+			return fillArr(pixelSize, 4);
+		case 2: {
+			const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction);
+			const tr = transformBorderRadiusSizeValue(canvas, value[1], pixelSize, direction);
+			if (last) return [
+				pixelSize,
+				tr,
+				tr,
+				pixelSize
+			];
+			if (first) return [
+				tl,
+				pixelSize,
+				pixelSize,
+				tl
+			];
+			return fillArr(pixelSize, 4);
+		}
+		case 3: {
+			const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction);
+			const br = transformBorderRadiusSizeValue(canvas, value[2], pixelSize, direction);
+			const rest = transformBorderRadiusSizeValue(canvas, value[1], pixelSize, direction);
+			if (last) return [
+				pixelSize,
+				rest,
+				br,
+				pixelSize
+			];
+			if (first) return [
+				tl,
+				pixelSize,
+				pixelSize,
+				rest
+			];
+			return fillArr(pixelSize, 4);
+		}
+		default:
+			if (last) return [
+				pixelSize,
+				transformBorderRadiusSizeValue(canvas, value[1], pixelSize, direction),
+				transformBorderRadiusSizeValue(canvas, value[2], pixelSize, direction),
+				pixelSize
+			];
+			if (first) return [
+				transformBorderRadiusSizeValue(canvas, value[0], pixelSize, direction),
+				pixelSize,
+				pixelSize,
+				transformBorderRadiusSizeValue(canvas, value[3], pixelSize, direction)
+			];
+			return fillArr(pixelSize, 4);
+	}
 };
-const getInnerRadius = (canvas, value, pixelSize, first, last) => {
-  if (!value) return fillArr(pixelSize, 4);
-  if (!$(value)) {
-    const v = transformBorderRadiusSizeValue(canvas, value, pixelSize);
-    if (last) return [pixelSize, v, v, pixelSize];
-    if (first) return [v, pixelSize, pixelSize, v];
-    return fillArr(pixelSize, 4);
-  }
-  switch (value.length) {
-    case 1:
-      const v = transformBorderRadiusSizeValue(canvas, value[0], pixelSize);
-      if (last) return [pixelSize, v, v, pixelSize];
-      if (first) return [v, pixelSize, pixelSize, v];
-      return fillArr(pixelSize, 4);
-    case 2: {
-      const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize);
-      const tr = transformBorderRadiusSizeValue(canvas, value[1], pixelSize);
-      if (last) return [pixelSize, tr, tr, pixelSize];
-      if (first) return [tl, pixelSize, pixelSize, tl];
-      return fillArr(pixelSize, 4);
-    }
-    case 3: {
-      const tl = transformBorderRadiusSizeValue(canvas, value[0], pixelSize);
-      const br = transformBorderRadiusSizeValue(canvas, value[2], pixelSize);
-      const rest = transformBorderRadiusSizeValue(canvas, value[1], pixelSize);
-      if (last) return [pixelSize, rest, br, pixelSize];
-      if (first) return [tl, pixelSize, pixelSize, rest];
-      return fillArr(pixelSize, 4);
-    }
-    default:
-      if (last)
-        return [
-          pixelSize,
-          transformBorderRadiusSizeValue(canvas, value[1], pixelSize),
-          transformBorderRadiusSizeValue(canvas, value[2], pixelSize),
-          pixelSize
-        ];
-      if (first)
-        return [
-          transformBorderRadiusSizeValue(canvas, value[0], pixelSize),
-          pixelSize,
-          pixelSize,
-          transformBorderRadiusSizeValue(canvas, value[3], pixelSize)
-        ];
-      return fillArr(pixelSize, 4);
-  }
+var getRadius = (canvas, pixelSize, size, direction = "horizontal") => {
+	let originalRadius = transformBorderRadiusSizeValue(canvas, "50%", pixelSize, direction);
+	if (A(size)) originalRadius = ke(originalRadius, pixelSize, size / 2);
+	let radius = roundToPixel(originalRadius, pixelSize);
+	const rate = radius / pixelSize;
+	if (rate === 4 && originalRadius < pixelSize * 4.5) return pixelSize * 3;
+	if (rate === 6 && originalRadius < pixelSize * 6.25) return pixelSize * 5;
+	if (rate === 6 && originalRadius > pixelSize * 6.375) return pixelSize * 7;
+	return radius;
 };
-const getBorderRadius = (canvas, pixelSize, borderRadius, shape, size = "medium", inner = false, first = false, last = false) => {
-  if (!inBrowser()) {
-    return fillArr(pixelSize, 4);
-  }
-  if (!inner) {
-    if (borderRadius) {
-      return getRadiusFromValue(canvas, borderRadius, pixelSize);
-    }
-    switch (shape) {
-      case "round":
-      case "circle":
-        let radius = transformBorderRadiusSizeValue(canvas, "50%", pixelSize);
-        radius = Math.max(Math.round(radius / pixelSize) * pixelSize, pixelSize);
-        return fillArr(radius, 4);
-      default:
-        return fillArr(pixelSize, 4);
-    }
-  } else {
-    if (borderRadius) {
-      return getInnerRadius(canvas, borderRadius, pixelSize, first, last);
-    }
-    const globalComputedStyle = getComputedStyle(document.documentElement);
-    const height = parseInt(globalComputedStyle.getPropertyValue(`--px-${size}-base-size`)) + 2 * pixelSize;
-    switch (shape) {
-      case "round":
-        let radius = transformBorderRadiusSizeValue(canvas, "50%", pixelSize);
-        radius = clamp(radius, pixelSize, height / 2);
-        radius = Math.max(Math.round(radius / pixelSize) * pixelSize, pixelSize);
-        const roundArr = fillArr(radius, 4);
-        if (last) return roundArr.map((e, i) => i < 1 || i > 2 ? pixelSize : e);
-        if (first) return roundArr.map((e, i) => i > 0 && i < 3 ? pixelSize : e);
-        return fillArr(pixelSize, 4);
-      default:
-        return fillArr(pixelSize, 4);
-    }
-  }
+const getBorderRadius = (canvas, pixelSize, borderRadius, shape, size = "medium", inner = false, first = false, last = false, direction = "horizontal") => {
+	if (!inBrowser()) return fillArr(pixelSize, 4);
+	if (!inner) {
+		if (borderRadius) return getRadiusFromValue(canvas, borderRadius, pixelSize, direction);
+		switch (shape) {
+			case "round":
+			case "circle": return fillArr(getRadius(canvas, pixelSize, void 0, direction), 4);
+			default: return fillArr(pixelSize, 4);
+		}
+	} else {
+		if (borderRadius) return getInnerRadius(canvas, borderRadius, pixelSize, first, last, direction);
+		const height = size === "small" ? 20 : size === "large" ? 36 : 28 + 2 * pixelSize;
+		switch (shape) {
+			case "round":
+				const roundArr = fillArr(getRadius(canvas, pixelSize, height, direction), 4);
+				if (last) return roundArr.map((e, i) => i < 1 || i > 2 ? pixelSize : e);
+				if (first) return roundArr.map((e, i) => i > 0 && i < 3 ? pixelSize : e);
+				return fillArr(pixelSize, 4);
+			default: return fillArr(pixelSize, 4);
+		}
+	}
 };
 function calcWhenLeaveBaseline(pixelSize, borderRadius) {
-  return Math.ceil(
-    (-6 + Math.sqrt(36 - 48 * pixelSize + 32 * pixelSize * borderRadius)) / (8 * pixelSize)
-  ) * pixelSize;
+	const step = pixelSize * 4 < borderRadius ? Math.round(pixelSize / 2) : pixelSize * 7 < borderRadius ? Math.round(pixelSize / 4 * 3) : pixelSize;
+	return Math.ceil((-6 + Math.sqrt(36 - 48 * step + 32 * step * borderRadius)) / (8 * step)) * step;
 }
 const calcPixelSize = () => {
-  if (!inBrowser()) {
-    return 4;
-  }
-  const globalComputedStyle = getComputedStyle(document.documentElement);
-  const pixelSize = parseInt(globalComputedStyle.getPropertyValue("--px-bit"));
-  return pixelSize;
+	if (!inBrowser()) return 4;
+	const globalComputedStyle = getComputedStyle(document.documentElement);
+	return parseInt(globalComputedStyle.getPropertyValue("--px-bit"));
 };
 const calcBorderCornerCenter = (borderRadius, width, height, pixelSize, paddingX = 0, paddingY = 0) => {
-  return [
-    [borderRadius[0], borderRadius[0]],
-    [width - paddingX - borderRadius[1] - pixelSize, borderRadius[1]],
-    [
-      width - paddingX - borderRadius[2] - pixelSize,
-      height - paddingY - borderRadius[2] - pixelSize
-    ],
-    [borderRadius[3], height - paddingY - borderRadius[3] - pixelSize]
-  ];
+	return [
+		[borderRadius[0], borderRadius[0]],
+		[width - paddingX - borderRadius[1] - pixelSize, borderRadius[1]],
+		[width - paddingX - borderRadius[2] - pixelSize, height - paddingY - borderRadius[2] - pixelSize],
+		[borderRadius[3], height - paddingY - borderRadius[3] - pixelSize]
+	];
+};
+const canvasPreprocess = (wrapperRef, canvasRef, paddingX = 0, paddingY = 0) => {
+	if (!canvasRef.value || !wrapperRef.value) return;
+	const ctx = canvasRef.value.getContext("2d", { willReadFrequently: true });
+	if (!ctx) return;
+	ctx.imageSmoothingEnabled = false;
+	const rect = wrapperRef.value.getBoundingClientRect();
+	const width = rect.width - paddingX * 2;
+	const height = rect.height - paddingY * 2;
+	if (width <= 0 || height <= 0) return;
+	canvasRef.value.width = width;
+	canvasRef.value.height = height;
+	return {
+		ctx,
+		width: canvasRef.value.width,
+		height: canvasRef.value.height,
+		rect,
+		canvas: canvasRef.value,
+		wrapper: wrapperRef.value
+	};
 };
-const canvasPreprocess = (wrapperRef, canvasRef) => {
-  if (!canvasRef.value || !wrapperRef.value) return;
-  const ctx = canvasRef.value.getContext("2d", { willReadFrequently: true });
-  if (!ctx) return;
-  ctx.imageSmoothingEnabled = false;
-  const rect = wrapperRef.value.getBoundingClientRect();
-  if (rect.width <= 0 || rect.height <= 0) {
-    return;
-  }
-  canvasRef.value.width = rect.width;
-  canvasRef.value.height = rect.height;
-  return {
-    ctx,
-    width: canvasRef.value.width,
-    height: canvasRef.value.height,
-    rect,
-    canvas: canvasRef.value
-  };
+var filterLine = (points) => {
+	if (points.length <= 2) return points;
+	const result = [points[0]];
+	for (let i = 1; i < points.length; i++) {
+		const current = points[i];
+		while (result.length >= 2) {
+			const prevPrev = result[result.length - 2];
+			const prev = result[result.length - 1];
+			const isHorizontal = prevPrev[1] === prev[1] && prev[1] === current[1];
+			const isVertical = prevPrev[0] === prev[0] && prev[0] === current[0];
+			if (!isHorizontal && !isVertical) break;
+			result.pop();
+		}
+		result.push(current);
+	}
+	while (result.length >= 3) {
+		const p1 = result[result.length - 3];
+		const p2 = result[result.length - 2];
+		const p3 = result[result.length - 1];
+		const isHorizontal = p1[1] === p2[1] && p2[1] === p3[1];
+		const isVertical = p1[0] === p2[0] && p2[0] === p3[0];
+		if (!isHorizontal && !isVertical) break;
+		result.pop();
+	}
+	if (result.length > 1 && result[result.length - 1][0] === result[0][0] && result[result.length - 1][1] === result[0][1]) result.pop();
+	return result;
 };
-export {
-  canvasPreprocess as a,
-  calcBorderCornerCenter as b,
-  calcPixelSize as c,
-  drawCircle as d,
-  calcWhenLeaveBaseline as e,
-  floodFill as f,
-  getBorderRadius as g
+var clockOrderSort = (points) => {
+	const centroid = points.reduce((acc, [x, y]) => {
+		acc[0] += x;
+		acc[1] += y;
+		return acc;
+	}, [0, 0]);
+	centroid[0] /= points.length;
+	centroid[1] /= points.length;
+	return points.sort((a, b) => {
+		const angleA = Math.atan2(a[1] - centroid[1], a[0] - centroid[0]);
+		return Math.atan2(b[1] - centroid[1], b[0] - centroid[0]) - angleA;
+	});
 };
+function floodFillEdge(ctx, startX, startY, fillColor) {
+	const w = ctx.canvas.width;
+	const h = ctx.canvas.height;
+	if (w <= 0 || h <= 0) return [];
+	const img = ctx.getImageData(0, 0, w, h);
+	const data32 = new Uint32Array(img.data.buffer);
+	const uint32Color = fillColor.a << 24 | fillColor.b << 16 | fillColor.g << 8 | fillColor.r;
+	const targetColor = data32[startY * w + startX];
+	if (targetColor === uint32Color) return [];
+	const filled = new Uint8Array(w * h);
+	const stack = [];
+	function fillLine(x, y, dy) {
+		if (y < 0 || y >= h) return null;
+		let left = x;
+		while (left > 0 && data32[y * w + (left - 1)] === targetColor && filled[y * w + (left - 1)] === 0) left--;
+		let right = x;
+		while (right < w - 1 && data32[y * w + (right + 1)] === targetColor && filled[y * w + (right + 1)] === 0) right++;
+		for (let i = left; i <= right; i++) {
+			const pos = y * w + i;
+			if (filled[pos] === 0) {
+				filled[pos] = 1;
+				data32[pos] = uint32Color;
+			}
+		}
+		return {
+			y,
+			left,
+			right,
+			dy
+		};
+	}
+	const firstSpan = fillLine(startX, startY, 1);
+	if (firstSpan) stack.push({
+		...firstSpan,
+		dy: 1
+	});
+	const secondSpan = fillLine(startX, startY - 1, -1);
+	if (secondSpan) stack.push({
+		...secondSpan,
+		dy: -1
+	});
+	while (stack.length) {
+		const { y, left, right, dy } = stack.pop();
+		const ny = y + dy;
+		if (ny < 0 || ny >= h) continue;
+		let x = left;
+		while (x <= right) {
+			const pos = ny * w + x;
+			if (data32[pos] !== targetColor || filled[pos] === 1) {
+				x++;
+				continue;
+			}
+			const newSpan = fillLine(x, ny, dy);
+			if (newSpan) stack.push(newSpan);
+			x = newSpan ? newSpan.right + 1 : x + 1;
+		}
+	}
+	const edgePoints = /* @__PURE__ */ new Set();
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) if (filled[y * w + x] === 1) {
+		let isEdge = false;
+		if (x === 0 || filled[y * w + (x - 1)] === 0) isEdge = true;
+		else if (x === w - 1 || filled[y * w + (x + 1)] === 0) isEdge = true;
+		else if (y === 0 || filled[(y - 1) * w + x] === 0) isEdge = true;
+		else if (y === h - 1 || filled[(y + 1) * w + x] === 0) isEdge = true;
+		if (isEdge) edgePoints.add(x * h + y);
+	}
+	const points = Array.from(edgePoints).map((enc) => {
+		return [Math.floor(enc / h), enc % h];
+	});
+	if (points.length === 0) return [];
+	clockOrderSort(points);
+	return filterLine(points);
+}
+function outerEdgePoints(ctx) {
+	const canvas = ctx.canvas;
+	const width = canvas.width;
+	const height = canvas.height;
+	const data = ctx.getImageData(0, 0, width, height).data;
+	const visited = Array.from({ length: height }, () => Array(width).fill(false));
+	const queue = [];
+	const edgePoints = /* @__PURE__ */ new Set();
+	const dirs = [
+		[0, 1],
+		[0, -1],
+		[1, 0],
+		[-1, 0]
+	];
+	for (let y = 0; y < height; y++) for (const x of [0, width - 1]) if (data[(y * width + x) * 4 + 3] === 0 && !visited[y][x]) {
+		visited[y][x] = true;
+		queue.push([x, y]);
+	}
+	for (let x = 0; x < width; x++) for (const y of [0, height - 1]) if (data[(y * width + x) * 4 + 3] === 0 && !visited[y][x]) {
+		visited[y][x] = true;
+		queue.push([x, y]);
+	}
+	while (queue.length > 0) {
+		const [cx, cy] = queue.shift();
+		for (const [dx, dy] of dirs) {
+			const nx = cx + dx;
+			const ny = cy + dy;
+			if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+			if (data[(ny * width + nx) * 4 + 3] > 0) {
+				const key = nx * height + ny;
+				edgePoints.add(key);
+			} else if (!visited[ny][nx]) {
+				visited[ny][nx] = true;
+				queue.push([nx, ny]);
+			}
+		}
+	}
+	const points = Array.from(edgePoints).map((key) => {
+		return [Math.floor(key / height), key % height];
+	});
+	if (points.length === 0) return [];
+	clockOrderSort(points);
+	return filterLine(points);
+}
+export { drawCircle as a, floodFillEdge as c, roundToPixel as d, canvasPreprocess as i, getBorderRadius as l, calcPixelSize as n, drawSmoothCircle as o, calcWhenLeaveBaseline as r, floodFill as s, calcBorderCornerCenter as t, outerEdgePoints as u };