@unicom-cloud/ui 0.8.168 → 0.8.170

package/rich-text/libs/core/rich.d.ts

@@ -0,0 +1,183 @@
+import type Block from '../blots/block.js';
+import type { BlockEmbed } from '../blots/block.js';
+import type Scroll from '../blots/scroll.js';
+import type { OpProps } from '../delta/index.js';
+import Delta from '../delta/index.js';
+import type Clipboard from '../modules/clipboard.js';
+import type History from '../modules/history.js';
+import type Keyboard from '../modules/keyboard.js';
+import type Uploader from '../modules/uploader.js';
+import * as Parchment from '../parchment/index.js';
+import Composition from './composition.js';
+import Editor from './editor.js';
+import type { EmitterSource } from './emitter.js';
+import Emitter from './emitter.js';
+import type { DebugLevel } from './logger.js';
+import type { Bounds } from './selection.js';
+import Selection, { Range } from './selection.js';
+import type { ThemeConstructor } from './theme.js';
+import Theme from './theme.js';
+import type { Rect, ScrollRectIntoViewOptions } from './utils/scrollRectIntoView.js';
+declare const globalRegistry: Parchment.Registry;
+/**
+ * Options for initializing a Rich instance
+ */
+export interface RichOptions {
+    theme?: string;
+    debug?: DebugLevel | boolean;
+    registry?: Parchment.Registry;
+    /**
+     * Whether to disable the editing
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * Placeholder text to display when the editor is empty
+     * @default ""
+     */
+    placeholder?: string;
+    bounds?: HTMLElement | string | null;
+    modules?: Record<string, unknown>;
+    /**
+     * A list of formats that are recognized and can exist within the editor contents.
+     * `null` means all formats are allowed.
+     * @default null
+     */
+    formats?: string[] | null;
+}
+/**
+ * Similar to RichOptions, but with all properties expanded to their default values,
+ * and all selectors resolved to HTMLElements.
+ */
+export interface ExpandedRichOptions extends Omit<RichOptions, 'theme' | 'formats'> {
+    theme: ThemeConstructor;
+    registry: Parchment.Registry;
+    container: HTMLElement;
+    modules: Record<string, unknown>;
+    bounds?: HTMLElement | null;
+    readOnly: boolean;
+}
+declare class Rich {
+    #private;
+    static DEFAULTS: {
+        bounds: null;
+        modules: {
+            clipboard: boolean;
+            keyboard: boolean;
+            history: boolean;
+            uploader: boolean;
+        };
+        placeholder: string;
+        readOnly: false;
+        registry: Parchment.Registry;
+        theme: string;
+    };
+    static events: {
+        readonly EDITOR_CHANGE: "editor-change";
+        readonly SCROLL_BEFORE_UPDATE: "scroll-before-update";
+        readonly SCROLL_BLOT_MOUNT: "scroll-blot-mount";
+        readonly SCROLL_BLOT_UNMOUNT: "scroll-blot-unmount";
+        readonly SCROLL_OPTIMIZE: "scroll-optimize";
+        readonly SCROLL_UPDATE: "scroll-update";
+        readonly SCROLL_EMBED_UPDATE: "scroll-embed-update";
+        readonly SELECTION_CHANGE: "selection-change";
+        readonly TEXT_CHANGE: "text-change";
+        readonly COMPOSITION_BEFORE_START: "composition-before-start";
+        readonly COMPOSITION_START: "composition-start";
+        readonly COMPOSITION_BEFORE_END: "composition-before-end";
+        readonly COMPOSITION_END: "composition-end";
+    };
+    static sources: {
+        readonly API: "api";
+        readonly SILENT: "silent";
+        readonly USER: "user";
+    };
+    static imports: Record<string, unknown>;
+    static debug(limit: DebugLevel | boolean): void;
+    static find(node: Node, bubble?: boolean): Parchment.Blot | Rich | null;
+    static import(name: string): unknown;
+    static register(...args: any[]): void;
+    elements: {
+        root: HTMLElement;
+        toolbar: HTMLElement;
+        container: HTMLElement;
+    };
+    container: HTMLElement;
+    root: HTMLElement;
+    scroll: Scroll;
+    emitter: Emitter;
+    protected allowReadOnlyEdits: boolean;
+    editor: Editor;
+    composition: Composition;
+    selection: Selection;
+    theme: Theme;
+    keyboard: Keyboard;
+    clipboard: Clipboard;
+    history: History;
+    uploader: Uploader;
+    options: ExpandedRichOptions;
+    constructor(elements: typeof this.elements, options?: RichOptions);
+    addContainer(container: string | HTMLElement, refNode?: Node | null, parentElement?: HTMLElement): HTMLElement;
+    blur(): void;
+    deleteText(index: number | Range, length?: number | EmitterSource, source?: EmitterSource): Delta;
+    disable(): void;
+    editReadOnly<T>(modifier: () => T): T;
+    enable(enabled?: boolean): void;
+    focus(options?: {
+        preventScroll?: boolean;
+    }): void;
+    format(name: string, value: unknown, source?: EmitterSource): Delta;
+    formatLine(index: number, length: number, name: string | Record<string, unknown>, value?: unknown | EmitterSource, source?: EmitterSource): Delta;
+    formatText(index: number | Range, length: number | string, name: string | unknown, value?: unknown | EmitterSource, source?: EmitterSource): Delta;
+    getBounds(index: number | Range, length?: number): Bounds | null;
+    getContents(index?: number, length?: number): Delta;
+    getFormat(index?: Range | number, length?: number): {
+        [format: string]: unknown;
+    };
+    getIndex(blot: Parchment.Blot): number;
+    getLength(): number;
+    getLeaf(index: number): [Parchment.LeafBlot | null, number];
+    getLine(index: number): [Block | BlockEmbed | null, number];
+    getLines(index?: Range | number, length?: number): (Block | BlockEmbed)[];
+    getModule(name: string): unknown;
+    getSelection(focus?: boolean): Range | null;
+    getSemanticHTML(index?: Range | number, length?: number): string;
+    getText(index?: Range | number, length?: number): string;
+    isBlank: () => boolean;
+    hasFocus(): boolean;
+    insertEmbed(index: number, embed: string, value: unknown, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, name?: string | Record<string, unknown> | EmitterSource, value?: unknown, source?: EmitterSource): Delta;
+    isEnabled(): boolean;
+    on(...args: Parameters<(typeof Emitter)['prototype']['on']>): Emitter;
+    once(...args: Parameters<(typeof Emitter)['prototype']['once']>): () => void;
+    off(...args: Parameters<(typeof Emitter)['prototype']['off']>): void;
+    offAll(): void;
+    removeFormat(index: number, length: number, source?: EmitterSource): Delta;
+    scrollRectIntoView(rect: Rect, options?: ScrollRectIntoViewOptions): void;
+    /**
+     * @deprecated Use Rich#scrollSelectionIntoView() instead.
+     */
+    scrollIntoView(): void;
+    /**
+     * Scroll the current selection into the visible area.
+     * If the selection is already visible, no scrolling will occur.
+     */
+    scrollSelectionIntoView(options?: ScrollRectIntoViewOptions): void;
+    setContents(delta: Delta | OpProps[], source?: EmitterSource): Delta;
+    setSelection(index: Range | null | number, length?: EmitterSource | number, source?: EmitterSource): void;
+    setText(text: string, source?: EmitterSource): Delta;
+    update(source?: EmitterSource): void;
+    updateContents(delta: Delta | OpProps[], source?: EmitterSource): Delta;
+    destroy(): void;
+}
+declare function expandConfig(containerOrSelector: HTMLElement | string, options: RichOptions): ExpandedRichOptions;
+type NormalizedIndexLength = [
+    number,
+    number,
+    Record<string, unknown>,
+    EmitterSource
+];
+declare function overload(index: Range | number, length?: number | string | Record<string, unknown> | EmitterSource, name?: string | unknown | Record<string, unknown> | EmitterSource, value?: unknown | EmitterSource, source?: EmitterSource): NormalizedIndexLength;
+export { Parchment, Range };
+export type { Bounds, DebugLevel, EmitterSource };
+export { Rich as default, expandConfig, globalRegistry, overload };

package/rich-text/libs/core/rich.js

@@ -0,0 +1,369 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { isBoolean as e, isFunction as t, isNumber as n, isObjectLike as r, isString as i, isUndefined as a } from "../../../utils/is.js";
+import o from "../../../utils/findRootElement.js";
+import { RICH_TEXT_CLASS_NAME_PREFIX as s } from "../../constants.js";
+import c from "../delta/index.js";
+import l from "../parchment/scope.js";
+import u from "../parchment/registry.js";
+import d from "../parchment/blot/abstract/parent.js";
+import f from "../parchment/blot/scroll.js";
+import { parchment_exports as p } from "../parchment/index.js";
+import m from "./logger.js";
+import h from "./emitter.js";
+import g from "./module.js";
+import _ from "./composition.js";
+import v, { Range as y } from "./selection.js";
+import b from "./editor.js";
+import x from "./theme.js";
+import S from "./utils/createRegistryWithFormats.js";
+import C from "./utils/scrollRectIntoView.js";
+import w from "lodash/merge";
+//#region components/pc/rich-text/libs/core/rich.ts
+var T = m("rich"), E = /* @__PURE__ */ new WeakMap(), D = [
+	"selectionchange",
+	"mousedown",
+	"mouseup",
+	"click"
+];
+function O(...e) {
+	let t = document.querySelectorAll(`.${s}-container`);
+	Array.from(t).forEach((t) => {
+		let n = E.get(t);
+		n?.emitter && n.emitter.handleDOM(...e);
+	});
+}
+function k() {
+	D.forEach((e) => {
+		document.addEventListener(e, O);
+	});
+}
+function A() {
+	D.forEach((e) => {
+		document.removeEventListener(e, O);
+	});
+}
+var j = new u();
+d.uiClass = `${s}-ui`;
+var M = class r {
+	static {
+		this.DEFAULTS = {
+			bounds: null,
+			modules: {
+				clipboard: !0,
+				keyboard: !0,
+				history: !0,
+				uploader: !0
+			},
+			placeholder: "",
+			readOnly: !1,
+			registry: j,
+			theme: "default"
+		};
+	}
+	static {
+		this.events = h.events;
+	}
+	static {
+		this.sources = h.sources;
+	}
+	static {
+		this.imports = {
+			delta: c,
+			parchment: p,
+			"core/module": g,
+			"core/theme": x
+		};
+	}
+	static debug(e) {
+		e === !0 && (e = "log"), m.level(e);
+	}
+	static find(e, t = !1) {
+		return E.get(e) || j.find(e, t);
+	}
+	static import(e) {
+		return this.imports[e] || T.error(`Cannot import ${e}. Are you sure it was registered?`), this.imports[e];
+	}
+	static register(...n) {
+		if (i(n[0])) {
+			let r = n[0], i = n[1], a = !!n[2];
+			this.imports[r] != null && !a && T.warn(`Overwriting ${r} with`, i), this.imports[r] = i, ["blots/", "formats/"].some((e) => r.startsWith(e)) && i && !e(i) && i.blotName !== "abstract" && j.register(i), t(i.register) && i.register(j);
+		} else {
+			let e = n[0], t = !!n[1], r = "attrName" in e ? e.attrName : e.blotName;
+			i(r) ? this.register(`formats/${r}`, e, t) : Object.entries(e).forEach(([e, n], r, i) => {
+				this.register(e, n, t);
+			});
+		}
+	}
+	constructor(e, t = {}) {
+		if (this.#e = (e) => {
+			e === h.events.TEXT_CHANGE && this.root.classList.toggle(`${s}-blank`, this.editor.isBlank());
+		}, this.#t = (e, t) => {
+			let n = this.selection.lastRange, [r] = this.selection.getRange(), i = n && r ? {
+				oldRange: n,
+				newRange: r
+			} : void 0;
+			L.call(this, () => this.editor.update(null, t, i), e);
+		}, this.#n = (e, t) => {
+			let n = this.selection.lastRange, [i] = this.selection.getRange(), a = n && i ? {
+				oldRange: n,
+				newRange: i
+			} : void 0;
+			L.call(this, () => {
+				let n = new c().retain(e.offset(this)).retain({ [e.statics.blotName]: t });
+				return this.editor.update(n, [], a);
+			}, r.sources.USER);
+		}, this.isBlank = () => this.editor.isBlank(), A(), k(), this.elements = e, this.options = I(o(this.elements?.container), t), this.container = this.options.container, this.container == null) {
+			T.error("Invalid Rich container", this.container);
+			return;
+		}
+		this.options.debug && r.debug(this.options.debug);
+		let n = this.container.innerHTML.trim();
+		this.container.classList.add(`${s}-container`), this.container.innerHTML = "", E.set(this.container, this), this.root = this.addContainer(`${s}-editor`), this.root.classList.add(`${s}-blank`), this.emitter = new h();
+		let i = f.blotName, a = this.options.registry.query(i);
+		if (!a || !("blotName" in a)) throw Error(`Cannot initialize Rich without "${i}" blot`);
+		if (this.scroll = new a(this.options.registry, this.root, { emitter: this.emitter }), this.editor = new b(this.scroll), this.selection = new v(this.scroll, this.emitter), this.options.readOnly || (this.composition = new _(this.scroll, this.emitter), this.theme = new this.options.theme(this, this.options), this.keyboard = this.theme.addModule("keyboard"), this.clipboard = this.theme.addModule("clipboard"), this.history = this.theme.addModule("history"), this.uploader = this.theme.addModule("uploader"), this.theme.addModule("input"), this.theme.addModule("uiNode"), this.theme.init(), this.emitter.on(h.events.EDITOR_CHANGE, this.#e), this.emitter.on(h.events.SCROLL_UPDATE, this.#t), this.emitter.on(h.events.SCROLL_EMBED_UPDATE, this.#n)), n && this.clipboard) {
+			let e = this.clipboard.convert({
+				html: `${n}<p><br></p>`,
+				text: "\n"
+			});
+			this.setContents(e);
+		}
+		this.history && this.history.clear(), this.options.placeholder && this.root.setAttribute("data-placeholder", this.options.placeholder), this.options.readOnly && this.disable(), this.allowReadOnlyEdits = !1;
+	}
+	#e;
+	#t;
+	#n;
+	addContainer(e, t = null, n) {
+		if (i(e)) {
+			let t = e;
+			e = document.createElement("div"), e.classList.add(t);
+		}
+		return n instanceof HTMLElement ? n.appendChild(e) : this.container.insertBefore(e, t), e;
+	}
+	blur() {
+		this.selection.setRange(null);
+	}
+	deleteText(e, t, n) {
+		return [e, t, , n] = R(e, t, n), L.call(this, () => this.editor.deleteText(e, t), n, e, -1 * t);
+	}
+	disable() {
+		this.enable(!1);
+	}
+	editReadOnly(e) {
+		this.allowReadOnlyEdits = !0;
+		let t = e();
+		return this.allowReadOnlyEdits = !1, t;
+	}
+	enable(e = !0) {
+		this.scroll.enable(e), this.container.classList.toggle(`${s}-disabled`, !e);
+	}
+	focus(e = {}) {
+		this.selection.focus(), e.preventScroll || this.scrollSelectionIntoView();
+	}
+	format(e, t, n = h.sources.API) {
+		return L.call(this, () => {
+			let n = this.getSelection(!0), r = new c();
+			if (n == null) return r;
+			if (this.scroll.query(e, l.BLOCK)) r = this.editor.formatLine(n.index, n.length, { [e]: t });
+			else if (n.length === 0) return this.selection.format(e, t), r;
+			else r = this.editor.formatText(n.index, n.length, { [e]: t });
+			return this.setSelection(n, h.sources.SILENT), r;
+		}, n);
+	}
+	formatLine(e, t, n, r, i) {
+		let a;
+		return [e, t, a, i] = R(e, t, n, r, i), L.call(this, () => this.editor.formatLine(e, t, a), i, e, 0);
+	}
+	formatText(e, t, n, r, i) {
+		let a;
+		return [e, t, a, i] = R(e, t, n, r, i), L.call(this, () => this.editor.formatText(e, t, a), i, e, 0);
+	}
+	getBounds(e, t = 0) {
+		let r = null;
+		if (r = n(e) ? this.selection.getBounds(e, t) : this.selection.getBounds(e.index, e.length), !r) return null;
+		let i = this.container.getBoundingClientRect();
+		return {
+			bottom: r.bottom - i.top,
+			height: r.height,
+			left: r.left - i.left,
+			right: r.right - i.left,
+			top: r.top - i.top,
+			width: r.width
+		};
+	}
+	getContents(e = 0, t = this.getLength() - e) {
+		return [e, t] = R(e, t), this.editor.getContents(e, t);
+	}
+	getFormat(e = this.getSelection(!0), t = 0) {
+		return n(e) ? this.editor.getFormat(e, t) : this.editor.getFormat(e.index, e.length);
+	}
+	getIndex(e) {
+		return e.offset(this.scroll);
+	}
+	getLength() {
+		return this.scroll.length();
+	}
+	getLeaf(e) {
+		return this.scroll.leaf(e);
+	}
+	getLine(e) {
+		return this.scroll.line(e);
+	}
+	getLines(e = 0, t = Number.MAX_VALUE) {
+		return n(e) ? this.scroll.lines(e, t) : this.scroll.lines(e.index, e.length);
+	}
+	getModule(e) {
+		return this.theme.modules[e];
+	}
+	getSelection(e = !1) {
+		return e && this.focus(), this.update(), this.selection.getRange()[0];
+	}
+	getSemanticHTML(e = 0, t) {
+		return n(e) && (t ??= this.getLength() - e), [e, t] = R(e, t), this.editor.getHTML(e, t);
+	}
+	getText(e = 0, t) {
+		return n(e) && (t ??= this.getLength() - e), [e, t] = R(e, t), this.editor.getText(e, t);
+	}
+	hasFocus() {
+		return this.selection.hasFocus();
+	}
+	insertEmbed(e, t, n, i = r.sources.API) {
+		return L.call(this, () => this.editor.insertEmbed(e, t, n), i, e);
+	}
+	insertText(e, t, n, r, i) {
+		let a;
+		return [e, , a, i] = R(e, 0, n, r, i), L.call(this, () => this.editor.insertText(e, t, a), i, e, t.length);
+	}
+	isEnabled() {
+		return this.scroll.isEnabled();
+	}
+	on(...e) {
+		return this.emitter.on(...e);
+	}
+	once(...e) {
+		return this.emitter.once(...e);
+	}
+	off(...e) {
+		return this.emitter.off(...e);
+	}
+	offAll() {
+		return this.emitter.offAll();
+	}
+	removeFormat(e, t, n) {
+		return [e, t, , n] = R(e, t, n), L.call(this, () => this.editor.removeFormat(e, t), n, e);
+	}
+	scrollRectIntoView(e, t = {}) {
+		C(this.root, e, t);
+	}
+	scrollIntoView() {
+		console.warn("Rich#scrollIntoView() has been deprecated and will be removed in the near future. Please use Rich#scrollSelectionIntoView() instead."), this.scrollSelectionIntoView();
+	}
+	scrollSelectionIntoView(e = {}) {
+		let t = this.selection.lastRange, n = t && this.selection.getBounds(t.index, t.length);
+		n && this.scrollRectIntoView(n, e);
+	}
+	setContents(e, t = h.sources.API) {
+		return L.call(this, () => {
+			e = new c(e);
+			let t = this.getLength(), n = this.editor.deleteText(0, t), r = this.editor.insertContents(0, e), i = this.editor.deleteText(this.getLength() - 1, 1);
+			return n.compose(r).compose(i);
+		}, t);
+	}
+	setSelection(e, t, n) {
+		e == null ? this.selection.setRange(null, t || r.sources.API) : ([e, t, , n] = R(e, t, n), this.selection.setRange(new y(Math.max(0, e), t), n), n !== h.sources.SILENT && this.scrollSelectionIntoView());
+	}
+	setText(e, t = h.sources.API) {
+		let n = new c().insert(e);
+		return this.setContents(n, t);
+	}
+	update(e = h.sources.USER) {
+		let t = this.scroll.update(e);
+		return this.selection.update(e), t;
+	}
+	updateContents(e, t = h.sources.API) {
+		return L.call(this, () => (e = new c(e), this.editor.applyDelta(e)), t, !0);
+	}
+	destroy() {
+		this.scroll && this.scroll.destroy(), this.editor && this.editor.destroy(), this.selection && this.selection.destroy(), this.composition && this.composition.destroy(), this.theme && this.theme.destroy(), this.keyboard && this.keyboard.destroy(), this.clipboard && this.clipboard.destroy(), this.history && this.history.destroy(), this.uploader && this.uploader.destroy(), this.options.readOnly, this.emitter.off(h.events.EDITOR_CHANGE, this.#e), this.emitter.off(h.events.SCROLL_UPDATE, this.#t), this.emitter.off(h.events.SCROLL_EMBED_UPDATE, this.#n), this.emitter.destroy(), this.offAll(), setTimeout(() => {
+			let e = document.querySelectorAll(`.${s}-container`);
+			Array.from(e).length || A();
+		}, 27), E.delete(this.container);
+	}
+};
+function N(e) {
+	return i(e) ? document.querySelector(e) : e;
+}
+function P(e) {
+	return Object.entries(e ?? {}).reduce((e, [t, n]) => ({
+		...e,
+		[t]: n === !0 ? {} : n
+	}), {});
+}
+function F(e) {
+	return Object.fromEntries(Object.entries(e).filter((e) => !a(e[1])));
+}
+function I(e, t) {
+	let n = N(e);
+	if (!n) throw Error("Invalid Rich container");
+	let r = !t.theme || t.theme === M.DEFAULTS.theme ? M.import("themes/default") ?? x : M.import(`themes/${t.theme}`);
+	if (!r) throw Error(`Invalid theme ${t.theme}. Did you register it?`);
+	let { modules: i, ...a } = M.DEFAULTS, { modules: o, ...s } = r.DEFAULTS;
+	i.clipboard = i.uploader = i.history = i.keyboard = !t.readOnly;
+	let c = P(t.modules);
+	c != null && c.toolbar && c.toolbar.constructor !== Object && (c = {
+		...c,
+		toolbar: { container: c.toolbar }
+	});
+	let l = w({}, P(i), P(o), c), u = {
+		...a,
+		...F(s),
+		...F(t)
+	}, d = t.registry;
+	return d ? t.formats && T.warn("Ignoring \"formats\" option because \"registry\" is specified") : d = t.formats ? S(t.formats, u.registry, T) : u.registry, {
+		...u,
+		registry: d,
+		container: n,
+		theme: r,
+		modules: Object.entries(l).reduce((e, [t, n]) => {
+			if (!n) return e;
+			let r = M.import(`modules/${t}`);
+			return r == null ? (T.error(`Cannot load ${t} module. Are you sure you registered it?`), e) : {
+				...e,
+				[t]: w({}, r.DEFAULTS || {}, n)
+			};
+		}, {}),
+		bounds: N(u.bounds)
+	};
+}
+function L(e, t, n, r) {
+	if (!this.isEnabled() && t === h.sources.USER && !this.allowReadOnlyEdits) return new c();
+	let i = n == null ? null : this.getSelection(), a = this.editor.delta, o = e();
+	if (i != null && (n === !0 && (n = i.index), r == null ? i = z(i, o, t) : r !== 0 && (i = z(i, n, r, t)), this.setSelection(i, h.sources.SILENT)), o.length() > 0) {
+		let e = [
+			h.events.TEXT_CHANGE,
+			o,
+			a,
+			t
+		];
+		this.emitter.emit(h.events.EDITOR_CHANGE, ...e), t !== h.sources.SILENT && this.emitter.emit(...e);
+	}
+	return o;
+}
+function R(e, t, a, o, s) {
+	let c = {};
+	return n(e.index) && n(e.length) ? n(t) ? (t = e.length, e = e.index) : (s = o, o = a, a = t, t = e.length, e = e.index) : n(t) || (s = o, o = a, a = t, t = 0), r(a) ? (c = a, s = o) : i(a) && (o == null ? s = a : c[a] = o), s ||= h.sources.API, [
+		e,
+		t,
+		c,
+		s
+	];
+}
+function z(e, r, i, a) {
+	let o = n(i) ? i : 0;
+	if (e == null) return null;
+	let s, c;
+	return r && t(r.transformPosition) ? [s, c] = [e.index, e.index + e.length].map((e) => r.transformPosition(e, a !== h.sources.USER)) : [s, c] = [e.index, e.index + e.length].map((e) => e < r || e === r && a === h.sources.USER ? e : o >= 0 ? e + o : Math.max(r, e + o)), new y(s, c - s);
+}
+//#endregion
+export { M as Rich };
+/* 独立思考，明辨是非 */