@unicom-cloud/ui 0.8.168 → 0.8.169

package/draw/libs/jotai-scope/ScopeProvider/index.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentType, PropsWithChildren, ReactNode } from 'react';
+import { useStore } from '../../jotai/react';
+import type { INTERNAL_Store as Store } from '../../jotai/vanilla/internals';
+import type { AnyAtom, AtomDefault } from '../types';
+type BaseProps = PropsWithChildren<{
+    atoms?: Iterable<AnyAtom | AtomDefault>;
+    atomFamilies?: Iterable<unknown>;
+    name?: string;
+}>;
+type ProviderProps = {
+    store: Store;
+    children: ReactNode;
+};
+type ScopeProviderComponent = {
+    (props: {
+        atoms: Iterable<AnyAtom | AtomDefault>;
+    } & BaseProps): React.JSX.Element;
+    (props: {
+        atomFamilies: Iterable<unknown>;
+    } & BaseProps): React.JSX.Element;
+    (props: PropsWithChildren<{
+        scope: Store;
+    }>): React.JSX.Element;
+};
+export declare function createScopeProvider(ProviderComponent: ComponentType<ProviderProps>, useStoreHook: typeof useStore): ScopeProviderComponent;
+export declare const ScopeProvider: ScopeProviderComponent;
+export {};

package/draw/libs/jotai-scope/ScopeProvider/index.js

@@ -0,0 +1,47 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { Provider as e, useStore as t } from "../../jotai/react/Provider.js";
+import "../../jotai/react.js";
+import { useHydrateAtoms as n } from "../../jotai/react/utils/useHydrateAtoms.js";
+import "../../jotai/utils.js";
+import { isEqualSize as r } from "../utils.js";
+import { cleanup as i, createScope as a, storeScopeMap as o } from "./scope.js";
+import { createElement as s, useEffect as c, useState as l } from "react";
+//#region components/pc/draw/libs/jotai-scope/ScopeProvider/index.tsx
+function u(e, t) {
+	return function(u) {
+		let { atoms: d = [], atomFamilies: f = [], children: p, scope: m, name: h } = u, g = t(), _ = Array.from(d, (e) => Array.isArray(e) ? e[0] : e);
+		function v() {
+			return [m ?? a({
+				atoms: _,
+				atomFamilies: f,
+				parentStore: g,
+				name: h
+			}), function(e) {
+				return g !== e.parentStore || !r(_, e.atoms) || !r(f, e.atomFamilies) || m !== e.providedScope;
+			}];
+		}
+		let [[y, b], x] = l(v);
+		if (b({
+			atoms: _,
+			atomFamilies: f,
+			parentStore: g,
+			providedScope: m
+		})) {
+			let e = o.get(y);
+			e && i(e), x(v);
+		}
+		return n(Array.from(d).filter(Array.isArray), { store: y }), c(() => {
+			let e = o.get(y);
+			return () => {
+				e && i(e);
+			};
+		}, [y]), s(e, {
+			store: y,
+			children: p
+		});
+	};
+}
+var d = u(e, t);
+//#endregion
+export { d as ScopeProvider, u as createScopeProvider };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai-scope/ScopeProvider/scope.d.ts

@@ -0,0 +1,16 @@
+import type { Atom } from '../../jotai';
+import type { INTERNAL_Store as Store } from '../../jotai/vanilla/internals';
+import type { AnyAtom, Scope } from '../types';
+/** WeakMap to store the scope associated with each scoped store */
+export declare const storeScopeMap: WeakMap<Store, Scope>;
+export declare function getAtom<T>(scope: Scope, atom: Atom<T>, implicitScope?: Scope): [Atom<T>, Scope?];
+export declare function cleanup(scope: Scope): void;
+export declare function prepareWriteAtom<T extends AnyAtom>(scope: Scope, atom: T, originalAtom: T, implicitScope: Scope | undefined, writeScope: Scope | undefined): (() => void) | undefined;
+type CreateScopeProps = {
+    atoms?: Iterable<AnyAtom>;
+    atomFamilies?: Iterable<unknown>;
+    parentStore: Store;
+    name?: string;
+};
+export declare function createScope({ atoms, atomFamilies, parentStore, name: scopeName, }: CreateScopeProps): Store;
+export {};

package/draw/libs/jotai-scope/ScopeProvider/scope.js

@@ -0,0 +1,264 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { atom as e } from "../../jotai/vanilla/atom.js";
+import { buildStore as t, getBuildingBlocks as n } from "../../jotai/vanilla/internals.js";
+import "../../jotai/index.js";
+import { isWritableAtom as r } from "../utils.js";
+import i from "lodash/isUndefined";
+//#region components/pc/draw/libs/jotai-scope/ScopeProvider/scope.ts
+var a = /* @__PURE__ */ new WeakMap(), o = {}, { read: s, write: c } = e(null);
+function l(e, t, n) {
+	let [r, i, a, , c] = e, u = r.get(t);
+	if (u) return u;
+	if (n === e) {
+		let r = i.get(t);
+		return r || (r = [m(e, t, n), n], i.set(t, r)), r;
+	}
+	let d = n ?? o, f = a.get(d);
+	f || (f = /* @__PURE__ */ new WeakMap(), a.set(d, f));
+	let p = f.get(t);
+	if (!p) {
+		let [r, i] = c ? l(c, t, n) : [t];
+		p = [t.read === s ? r : m(e, t, i), i], f.set(t, p);
+	}
+	return p;
+}
+function u(e) {
+	for (let t of e[5]) t();
+}
+function d(e, t, n, i, a) {
+	if (n.read === s && r(n) && r(t) && n.write !== c && e !== i) {
+		let { write: r } = n;
+		return t.write = p(e, n.write.bind(n), i, a), () => {
+			t.write = r;
+		};
+	}
+}
+function f(e, t, n) {
+	return function(r, i) {
+		return t(function(t) {
+			let [i] = l(e, t, n);
+			return r(i);
+		}, i);
+	};
+}
+function p(e, t, n, r = n) {
+	return function(i, a, ...o) {
+		return t(function(t) {
+			let [r] = l(e, t, n);
+			return i(r);
+		}, function(t, ...i) {
+			let [o] = l(e, t, n), s = d(e, o, t, n, r);
+			try {
+				return a(o, ...i);
+			} finally {
+				s?.();
+			}
+		}, ...o);
+	};
+}
+function m(e, t, n) {
+	let i = Object.getOwnPropertyDescriptors(t);
+	Object.keys(i).filter((e) => [
+		"read",
+		"write",
+		"debugLabel"
+	].includes(e)).forEach((e) => i[e].configurable = !0);
+	let a = Object.getPrototypeOf(t), o = Object.create(a, i);
+	return o.read !== s && (o.read = f(e, t.read.bind(t), n)), r(o) && r(t) && o.write !== c && (o.write = p(e, t.write.bind(t), n)), o;
+}
+function h({ atoms: e = [], atomFamilies: t = [], parentStore: n, name: r }) {
+	let i = new WeakSet(e), o = a.get(n), s = o?.[3] ?? n, c = [
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new WeakMap(),
+		s,
+		o,
+		/* @__PURE__ */ new Set(),
+		void 0
+	], l = c[0], u = c[5], d = g(c);
+	c[6] = d, Object.assign(d, { name: r }), a.set(d, c);
+	for (let t of new Set(e)) l.set(t, [m(c, t, c), c]);
+	for (let e of new Set(t)) {
+		for (let t of e.getParams()) {
+			let n = e(t);
+			l.has(n) || l.set(n, [m(c, n, c), c]);
+		}
+		let t = e.unstable_listen(({ type: e, atom: t }) => {
+			e === "CREATE" && !l.has(t) ? l.set(t, [m(c, t, c), c]) : e === "REMOVE" && !i.has(t) && l.delete(t);
+		});
+		u.add(t);
+	}
+	return d;
+}
+function g(e) {
+	let r = e[3], a = [...n(r)], o = a[21], s = a[22], c = a[23], u = a[9], f = {};
+	a[9] = (e, t) => u(p, t), a[21] = y(o), a[22] = _, a[23] = y(c), a[24] = ([ ...e]) => {
+		let t = [
+			b(e[0], m),
+			b(e[1], h),
+			b(e[2]),
+			x(e[3]),
+			e[4],
+			e[5],
+			C(e[6]),
+			y(e[7]),
+			y(e[8]),
+			e[9],
+			y(e[10]),
+			y(e[11], (e) => g(t[0], e)),
+			e[12],
+			e[13],
+			y(e[14]),
+			y(e[15]),
+			y(e[16]),
+			y(e[17]),
+			y(e[18]),
+			y(e[19]),
+			y(e[20]),
+			y(e[21]),
+			y(e[22]),
+			y(e[23]),
+			() => e
+		];
+		return t;
+	};
+	let p = t(...a);
+	return p;
+	function m(t) {
+		let n = /* @__PURE__ */ new WeakMap();
+		return function(r) {
+			let i = n.get(r);
+			if (i) return i;
+			let a = t(r);
+			if (a) return i = {
+				...a,
+				d: b(a.d, function(t) {
+					return (n) => t(l(e, n)[0]);
+				}),
+				p: x(a.p),
+				get n() {
+					return a.n;
+				},
+				set n(e) {
+					a.n = e;
+				},
+				get v() {
+					return a.v;
+				},
+				set v(e) {
+					a.v = e;
+				},
+				get e() {
+					return a.e;
+				},
+				set e(e) {
+					a.e = e;
+				}
+			}, n.set(r, i), i;
+		};
+	}
+	function h(e) {
+		let t = /* @__PURE__ */ new WeakMap();
+		return function(n) {
+			let r = t.get(n);
+			if (r) return r;
+			let i = e(n);
+			if (i) return r = {
+				...i,
+				d: x(i.d),
+				t: x(i.t),
+				get u() {
+					return i.u;
+				},
+				set u(e) {
+					i.u = e;
+				}
+			}, t.set(n, r), r;
+		};
+	}
+	function g(e, t) {
+		return function(n, r) {
+			return e.get(r) || (e.set(r, t(n, r)), e.get(r));
+		};
+	}
+	function _(t, n, ...r) {
+		let [i, a] = l(e, n), o = d(e, i, n, a, e);
+		try {
+			return s(t, i, ...r);
+		} finally {
+			o?.();
+		}
+	}
+	function v(t, n) {
+		return function(r, ...i) {
+			let [a] = l(e, r);
+			return (n ? n(t) : t)(a, ...i);
+		};
+	}
+	function y(t, n) {
+		return function(r, i, ...a) {
+			let [o] = l(e, i);
+			return (n ? n(t) : t)(r, o, ...a);
+		};
+	}
+	function b(e, t) {
+		return {
+			get: v(e.get.bind(e), t),
+			set: v(e.set.bind(e)),
+			has: v(e.has.bind(e)),
+			delete: v(e.delete.bind(e))
+		};
+	}
+	function x(t) {
+		return {
+			get size() {
+				return t.size;
+			},
+			add: v(t.add.bind(t)),
+			has: v(t.has.bind(t)),
+			delete: v(t.delete.bind(t)),
+			clear: t.clear.bind(t),
+			forEach: (e) => t.forEach(v(e)),
+			*[Symbol.iterator]() {
+				for (let n of t) yield l(e, n)[0];
+			}
+		};
+	}
+	function S(t) {
+		if (!t) return;
+		let n = v(t);
+		return n.add = function(n, r) {
+			if (i(n)) return t.add(void 0, r);
+			let [a] = l(e, n);
+			return t.add(a, r);
+		}, n;
+	}
+	function C(e) {
+		let t = {
+			get f() {
+				return e.f;
+			},
+			set f(t) {
+				e.f = t;
+			}
+		};
+		return Object.defineProperties(t, Object.fromEntries([
+			"r",
+			"c",
+			"m",
+			"u"
+		].map((t) => [t, {
+			get() {
+				return f[t] ??= S(e[t]);
+			},
+			set(n) {
+				delete f[t], e[t] = n;
+			},
+			configurable: !0,
+			enumerable: !0
+		}]))), Object.assign(t, e);
+	}
+}
+//#endregion
+export { u as cleanup, h as createScope, a as storeScopeMap };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai-scope/createIsolation.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+import { useAtom as useAtomOrig, useAtomValue as useAtomValueOrig, useSetAtom as useSetAtomOrig, useStore as useStoreOrig } from '../jotai/react';
+import type { INTERNAL_Store as Store } from '../jotai/vanilla/internals';
+import { createScopeProvider } from './ScopeProvider';
+import type { AnyWritableAtom } from './types';
+type CreateIsolationResult = {
+    Provider: (props: {
+        store?: Store;
+        initialValues?: Iterable<readonly [AnyWritableAtom, unknown]>;
+        children: ReactNode;
+    }) => React.JSX.Element;
+    ScopeProvider: ReturnType<typeof createScopeProvider>;
+    useStore: typeof useStoreOrig;
+    useAtom: typeof useAtomOrig;
+    useAtomValue: typeof useAtomValueOrig;
+    useSetAtom: typeof useSetAtomOrig;
+};
+export declare function createIsolation(): CreateIsolationResult;
+export {};

package/draw/libs/jotai-scope/createIsolation.js

@@ -0,0 +1,50 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { createStore as e } from "../jotai/vanilla/store.js";
+import { useStore as t } from "../jotai/react/Provider.js";
+import { useAtomValue as n } from "../jotai/react/useAtomValue.js";
+import { useSetAtom as r } from "../jotai/react/useSetAtom.js";
+import { useAtom as i } from "../jotai/react/useAtom.js";
+import "../jotai/react.js";
+import { useHydrateAtoms as a } from "../jotai/react/utils/useHydrateAtoms.js";
+import "../jotai/react/utils.js";
+import { createScopeProvider as o } from "./ScopeProvider/index.js";
+import { createContext as s, createElement as c, useContext as l, useRef as u } from "react";
+//#region components/pc/draw/libs/jotai-scope/createIsolation.tsx
+function d() {
+	let d = s(null);
+	function f({ store: t, initialValues: n = [], children: r }) {
+		let i = u(t);
+		return i.current ||= e(), a(n, { store: i.current }), c(d.Provider, {
+			value: i.current,
+			children: r
+		});
+	}
+	let p = ((e) => {
+		let n = l(d);
+		if (!n) throw Error("Missing Provider from createIsolation");
+		return t({
+			store: n,
+			...e
+		});
+	});
+	return {
+		Provider: f,
+		ScopeProvider: o(f, p),
+		useStore: p,
+		useAtom: ((e, t) => i(e, {
+			store: p(),
+			...t
+		})),
+		useAtomValue: ((e, t) => n(e, {
+			store: p(),
+			...t
+		})),
+		useSetAtom: ((e, t) => r(e, {
+			store: p(),
+			...t
+		}))
+	};
+}
+//#endregion
+export { d as createIsolation };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai-scope/index.d.ts

@@ -0,0 +1,3 @@
+export { createIsolation } from './createIsolation';
+export { ScopeProvider } from './ScopeProvider';
+export { createScope } from './ScopeProvider/scope';

package/draw/libs/jotai-scope/index.js

@@ -0,0 +1,14 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { __exportAll as e } from "../../../.virtual/_rolldown/runtime.js";
+import { createScope as t } from "./ScopeProvider/scope.js";
+import { ScopeProvider as n } from "./ScopeProvider/index.js";
+import { createIsolation as r } from "./createIsolation.js";
+//#region components/pc/draw/libs/jotai-scope/index.ts
+var i = /* @__PURE__ */ e({
+	ScopeProvider: () => n,
+	createIsolation: () => r,
+	createScope: () => t
+});
+//#endregion
+export { i as jotai_scope_exports };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai-scope/types.d.ts

@@ -0,0 +1,53 @@
+import type { Atom, WritableAtom } from '../jotai';
+import type { INTERNAL_StoreHooks, INTERNAL_Store as Store } from '../jotai/vanilla/internals';
+export type AnyAtom = Atom<any> | AnyWritableAtom;
+export type AnyWritableAtom = WritableAtom<any, any[], any>;
+/** WeakMap-like, but each value must be [same A as key, Scope?] */
+export type AtomPairMap = {
+    set<A extends AnyAtom>(key: A, value: [A, Scope?]): AtomPairMap;
+    get<A extends AnyAtom>(key: A): [A, Scope?] | undefined;
+    has(key: AnyAtom): boolean;
+    delete(key: AnyAtom): boolean;
+};
+export interface ExplicitMap extends AtomPairMap {
+}
+export interface ImplicitMap extends AtomPairMap {
+}
+export type InheritedSource = WeakMap<Scope | object, AtomPairMap>;
+export type CleanupFamiliesSet = Set<() => void>;
+export type Scope = [
+    explicitMap: ExplicitMap,
+    implicitMap: ImplicitMap,
+    inheritedSource: InheritedSource,
+    baseStore: Store,
+    parentScope: Scope | undefined,
+    cleanupFamiliesSet: CleanupFamiliesSet,
+    scopedStore: Store
+] & {
+    /** @debug */
+    name?: string;
+    /** @debug */
+    toString?: () => string;
+};
+export type AtomDefault = readonly [AnyWritableAtom, unknown];
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type StoreHooks = Mutable<INTERNAL_StoreHooks>;
+export type StoreHookForAtoms = NonNullable<StoreHooks['c']>;
+export type WeakMapLike<K extends object, V> = {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+};
+export type SetLike<T> = {
+    readonly size: number;
+    add(value: T): void;
+    has(value: T): boolean;
+    delete(value: T): boolean;
+    clear(): void;
+    forEach(callback: (value: T) => void): void;
+    [Symbol.iterator](): IterableIterator<T>;
+};
+export {};

package/draw/libs/jotai-scope/utils.d.ts

@@ -0,0 +1,6 @@
+import type { AnyAtom, AnyWritableAtom } from './types';
+export declare function isEqualSize(aIter: Iterable<unknown>, bIter: Iterable<unknown>): boolean;
+export declare function toNameString(this: {
+    name: string;
+}): string;
+export declare function isWritableAtom(atom: AnyAtom): atom is AnyWritableAtom;

package/draw/libs/jotai-scope/utils.js

@@ -0,0 +1,12 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+//#region components/pc/draw/libs/jotai-scope/utils.ts
+function e(e, t) {
+	let n = new Set(e), r = new Set(t);
+	return e === t || n.size === r.size && Array.from(n).every(r.has.bind(r));
+}
+function t(e) {
+	return "write" in e;
+}
+//#endregion
+export { e as isEqualSize, t as isWritableAtom };
+/* 独立思考，明辨是非 */

package/draw/libs/laser-pointer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './state';
+export type { Point } from './math';

package/draw/libs/laser-pointer/index.js

@@ -0,0 +1,8 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { __exportAll as e } from "../../../.virtual/_rolldown/runtime.js";
+import { LaserPointer as t } from "./state.js";
+//#region components/pc/draw/libs/laser-pointer/index.ts
+var n = /* @__PURE__ */ e({ LaserPointer: () => t });
+//#endregion
+export { n as laser_pointer_exports };
+/* 独立思考，明辨是非 */

package/draw/libs/laser-pointer/math.d.ts

@@ -0,0 +1,16 @@
+export type Point = [x: number, y: number, r: number];
+export declare function add([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function sub([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function smul([x, y, r]: Point, s: number): Point;
+export declare function norm([x, y, r]: Point): Point;
+export declare function rot([x, y, r]: Point, rad: number): Point;
+export declare function plerp(a: Point, b: Point, t: number): Point;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function angle(p: Point, p1: Point, p2: Point): number;
+export declare function normAngle(a: number): number;
+export declare function mag([x, y]: Point): number;
+export declare function dist([ax, ay]: Point, [bx, by]: Point): number;
+export declare function getCircleAndPerpendicularLineIntersectionsAtPoint(point: Point, direction: Point, radius: number): [Point, Point];
+export declare function runLength(ps: Point[]): number;
+export declare const clamp: (v: number, min: number, max: number) => number;
+export declare function distancePointToSegment(p3: Point, p1: Point, p2: Point): number;

package/draw/libs/laser-pointer/math.js

@@ -0,0 +1,72 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+//#region components/pc/draw/libs/laser-pointer/math.ts
+function e([e, t, n], [r, i, a]) {
+	return [
+		e + r,
+		t + i,
+		n + a
+	];
+}
+function t([e, t, n], [r, i, a]) {
+	return [
+		e - r,
+		t - i,
+		n - a
+	];
+}
+function n([e, t, n], r) {
+	return [
+		e * r,
+		t * r,
+		n * r
+	];
+}
+function r([e, t, n]) {
+	return [
+		e / Math.sqrt(e ** 2 + t ** 2),
+		t / Math.sqrt(e ** 2 + t ** 2),
+		n
+	];
+}
+function i([e, t, n], r) {
+	return [
+		Math.cos(r) * e - Math.sin(r) * t,
+		Math.sin(r) * e + Math.cos(r) * t,
+		n
+	];
+}
+function a(r, i, a) {
+	return e(r, n(t(i, r), a));
+}
+function o(e, t, n) {
+	return Math.atan2(n[1] - e[1], n[0] - e[0]) - Math.atan2(t[1] - e[1], t[0] - e[0]);
+}
+function s(e) {
+	return Math.atan2(Math.sin(e), Math.cos(e));
+}
+function c([e, t]) {
+	return Math.sqrt(e ** 2 + t ** 2);
+}
+function l([e, t], [n, r]) {
+	return Math.sqrt((n - e) ** 2 + (r - t) ** 2);
+}
+function u(e) {
+	if (e.length < 2) return 0;
+	let t = 0;
+	for (let n = 1; n <= e.length - 1; n++) t += l(e[n - 1], e[n]);
+	return t += l(e[e.length - 2], e[e.length - 1]), t;
+}
+var d = (e, t, n) => Math.max(t, Math.min(n, e));
+function f(e, t, n) {
+	let r = l(t, n);
+	if (r === 0) return l(e, t);
+	let i = d(((e[0] - t[0]) * (n[0] - t[0]) + (e[1] - t[1]) * (n[1] - t[1])) / r ** 2, 0, 1);
+	return l([
+		t[0] + i * (n[0] - t[0]),
+		t[1] + i * (n[1] - t[1]),
+		e[2]
+	], e);
+}
+//#endregion
+export { e as add, o as angle, l as dist, f as distancePointToSegment, c as mag, r as norm, s as normAngle, a as plerp, i as rot, u as runLength, n as smul, t as sub };
+/* 独立思考，明辨是非 */

package/draw/libs/laser-pointer/simplify.d.ts

@@ -0,0 +1,2 @@
+import type { Point } from './math';
+export declare function douglasPeucker(points: Point[], epsilon: number): Point[];

package/draw/libs/laser-pointer/simplify.js

@@ -0,0 +1,29 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { distancePointToSegment as e } from "./math.js";
+//#region components/pc/draw/libs/laser-pointer/simplify.ts
+function t(n, r) {
+	if (r === 0 || n.length <= 2) return n;
+	let i = n[0], a = n[n.length - 1], [o, s] = n.reduce(([t, n], r, o) => {
+		let s = e(r, i, a);
+		return s > t ? [s, o] : [t, n];
+	}, [0, -1]);
+	if (o >= r) {
+		let e = n[s];
+		return [
+			...t([
+				i,
+				...n.slice(1, s),
+				e
+			], r).slice(0, -1),
+			e,
+			...t([
+				e,
+				...n.slice(s, -1),
+				a
+			], r).slice(1)
+		];
+	} else return [i, a];
+}
+//#endregion
+export { t as douglasPeucker };
+/* 独立思考，明辨是非 */

package/draw/libs/laser-pointer/state.d.ts

@@ -0,0 +1,31 @@
+import type { Point } from './math';
+export type SizeMappingDetails = {
+    pressure: number;
+    runningLength: number;
+    currentIndex: number;
+    totalLength: number;
+};
+export type LaserPointerOptions = {
+    size: number;
+    streamline: number;
+    simplify: number;
+    simplifyPhase: 'tail' | 'output' | 'input';
+    keepHead: boolean;
+    sizeMapping: (details: SizeMappingDetails) => number;
+};
+export declare class LaserPointer {
+    #private;
+    static defaults: LaserPointerOptions;
+    static constants: {
+        cornerDetectionMaxAngle: number;
+        cornerDetectionVariance: (s: number) => 1 | 0.5;
+        maxTailLength: number;
+    };
+    options: LaserPointerOptions;
+    constructor(options: Partial<LaserPointerOptions>);
+    originalPoints: Point[];
+    addPoint(point: Point): void;
+    close(): void;
+    stabilizeTail(): void;
+    getStrokeOutline(sizeOverride?: number | undefined): Point[];
+}