inital commit

node_modules/jodit/esm/core/event-emitter/event-emitter.d.ts

@@ -0,0 +1,138 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/event-emitter/README.md]]
+ * @packageDocumentation
+ * @module event-emitter
+ */
+import type { CallbackFunction, CanArray, IEventEmitter, IEventEmitterOnOptions } from "../../types/index";
+/**
+ * The module editor's event manager
+ */
+export declare class EventEmitter implements IEventEmitter {
+    private __domEventsMap;
+    private __mutedEvents;
+    mute(event?: string): this;
+    isMuted(event?: string): boolean;
+    unmute(event?: string): this;
+    readonly __key: string;
+    private __doc;
+    private __eachEvent;
+    private __getStore;
+    private __removeStoreFromSubject;
+    private __prepareEvent;
+    private __triggerNativeEvent;
+    /**
+     * Get current event name
+     *
+     * @example
+     * ```javascript
+     * parent.e.on('openDialog closeDialog', function () {
+     *     if (parent.e.current === 'closeDialog') {
+     *         alert('Dialog was closed');
+     *     } else {
+     *         alert('Dialog was opened');
+     *     }
+     * });
+     * ```
+     */
+    get current(): string;
+    currents: string[];
+    /**
+     * Sets the handler for the specified event ( Event List ) for a given element
+     *
+     * @example
+     * ```javascript
+     * // set global handler
+     * editor.events.on('beforeCommand', function (command) {
+     *     alert('command');
+     * });
+     * ```
+     * * @example
+     * ```javascript
+     * // set global handler
+     * editor.events.on(document.body, 'click', function (e) {
+     *     alert(this.href);
+     * });
+     * ```
+     */
+    on(events: CanArray<string>, callback: CallbackFunction, options?: IEventEmitterOnOptions): this;
+    on(subjects: CanArray<HTMLElement | Window | object>, events: CanArray<string>, callback: CallbackFunction, options?: IEventEmitterOnOptions): this;
+    private __memoryDOMSubjectToHandler;
+    private __unmemoryDOMSubjectToHandler;
+    one(eventsOrSubjects: CanArray<string> | CanArray<HTMLElement | Window | object>, callbackOrEvents: CallbackFunction | CanArray<string>, optionsOrCallback: IEventEmitterOnOptions | CallbackFunction | void, opts?: IEventEmitterOnOptions): this;
+    /**
+     * Disable all handlers specified event ( Event List ) for a given element. Either a specific event handler.
+     *
+     * @param subjectOrEvents - The object which is disabled handlers
+     * @param eventsOrCallback - List of events, separated by a space or comma , which is necessary
+     * to disable the handlers for a given object
+     * @param handler - Specific event handler to be removed
+     *
+     * @example
+     * ```javascript
+     * var a = {name: "Anton"};
+     * parent.e.on(a, 'open', function () {
+     *     alert(this.name);
+     * });
+     *
+     * parent.e.fire(a, 'open');
+     * parent.e.off(a, 'open');
+     * var b = {name: "Ivan"}, hndlr = function () {
+     *  alert(this.name);
+     * };
+     * parent.e.on(b, 'open close', hndlr);
+     * parent.e.fire(a, 'open');
+     * parent.e.off(a, 'open', hndlr);
+     * parent.e.fire(a, 'close');
+     * parent.e.on('someGlobalEvents', function () {
+     *   console.log(this); // parent
+     * });
+     * parent.e.fire('someGlobalEvents');
+     * parent.e.off('someGlobalEvents');
+     * ```
+     */
+    off(events: CanArray<string>, callback?: CallbackFunction): this;
+    off(subjects: CanArray<Window | HTMLElement | object>, events?: CanArray<string>, callback?: CallbackFunction): this;
+    /**
+     * Stop execute all another listeners for this event
+     */
+    stopPropagation(events: string): void;
+    stopPropagation(subject: object, eventsList: string): void;
+    private __stopped;
+    private __removeStop;
+    private __isStopped;
+    /**
+     * Emits an event to all handlers and calls them
+     *
+     * @param subjectOrEvents - The object which is caused by certain events
+     * @param eventsList - List of events , separated by a space or comma
+     * @param args - Options for the event handler
+     * @returns `false` if one of the handlers return `false`
+     * @example
+     * ```javascript
+     * var dialog = new Jodit.modules.Dialog();
+     * parent.e.on('afterClose', function () {
+     *     dialog.destruct(); // will be removed from DOM
+     * });
+     * dialog.open('Hello world!!!');
+     * ```
+     *  or you can trigger native browser listener
+     * ```javascript
+     *  var events = new Jodit.modules.EventEmitter();
+     *  events.on(document.body, 'click',function (event) {
+     *      alert('click on ' + event.target.id );
+     *  });
+     *  events.fire(document.body.querySelector('div'), 'click');
+     * ```
+     *
+     */
+    fire(subjectOrEvents: string, ...args: any[]): any;
+    fire(subjectOrEvents: object, eventsList: string | Event, ...args: any[]): any;
+    private __isDestructed;
+    constructor(doc?: Document);
+    destruct(): void;
+}

node_modules/jodit/esm/core/event-emitter/event-emitter.js

@@ -0,0 +1,481 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+import { globalDocument, PASSIVE_EVENTS } from "../constants.js";
+import { splitArray } from "../helpers/array/split-array.js";
+import { isArray } from "../helpers/checker/is-array.js";
+import { isFunction } from "../helpers/checker/is-function.js";
+import { isString, isStringArray } from "../helpers/checker/is-string.js";
+import { error } from "../helpers/utils/error/index.js";
+import { defaultNameSpace, EventHandlersStore } from "./store.js";
+/**
+ * The module editor's event manager
+ */
+export class EventEmitter {
+    mute(event) {
+        this.__mutedEvents.add(event !== null && event !== void 0 ? event : '*');
+        return this;
+    }
+    isMuted(event) {
+        if (event && this.__mutedEvents.has(event)) {
+            return true;
+        }
+        return this.__mutedEvents.has('*');
+    }
+    unmute(event) {
+        this.__mutedEvents.delete(event !== null && event !== void 0 ? event : '*');
+        return this;
+    }
+    __eachEvent(events, callback) {
+        const eventParts = splitArray(events).map(e => e.trim());
+        eventParts.forEach(eventNameSpace => {
+            const eventAndNameSpace = eventNameSpace.split('.');
+            const namespace = eventAndNameSpace[1] || defaultNameSpace;
+            callback.call(this, eventAndNameSpace[0], namespace);
+        });
+    }
+    __getStore(subject) {
+        if (!subject) {
+            throw error('Need subject');
+        }
+        if (subject[this.__key] === undefined) {
+            const store = new EventHandlersStore();
+            Object.defineProperty(subject, this.__key, {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: store
+            });
+        }
+        return subject[this.__key];
+    }
+    __removeStoreFromSubject(subject) {
+        if (subject[this.__key] !== undefined) {
+            Object.defineProperty(subject, this.__key, {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: undefined
+            });
+        }
+    }
+    __triggerNativeEvent(element, event) {
+        const evt = this.__doc.createEvent('HTMLEvents');
+        if (isString(event)) {
+            evt.initEvent(event, true, true);
+        }
+        else {
+            evt.initEvent(event.type, event.bubbles, event.cancelable);
+            [
+                'screenX',
+                'screenY',
+                'clientX',
+                'clientY',
+                'target',
+                'srcElement',
+                'currentTarget',
+                'timeStamp',
+                'which',
+                'keyCode'
+            ].forEach(property => {
+                Object.defineProperty(evt, property, {
+                    value: event[property],
+                    enumerable: true
+                });
+            });
+            Object.defineProperty(evt, 'originalEvent', {
+                value: event,
+                enumerable: true
+            });
+        }
+        element.dispatchEvent(evt);
+    }
+    /**
+     * Get current event name
+     *
+     * @example
+     * ```javascript
+     * parent.e.on('openDialog closeDialog', function () {
+     *     if (parent.e.current === 'closeDialog') {
+     *         alert('Dialog was closed');
+     *     } else {
+     *         alert('Dialog was opened');
+     *     }
+     * });
+     * ```
+     */
+    get current() {
+        return this.currents[this.currents.length - 1];
+    }
+    on(eventsOrSubjects, callbackOrEvents, optionsOrCallback, opts) {
+        let subjects;
+        let events;
+        let callback;
+        let options;
+        if (isString(eventsOrSubjects) || isStringArray(eventsOrSubjects)) {
+            subjects = this;
+            events = eventsOrSubjects;
+            callback = callbackOrEvents;
+            options = optionsOrCallback;
+        }
+        else {
+            subjects = eventsOrSubjects;
+            events = callbackOrEvents;
+            callback = optionsOrCallback;
+            options = opts;
+        }
+        if (!(isString(events) || isStringArray(events)) ||
+            events.length === 0) {
+            throw error('Need events names');
+        }
+        if (!isFunction(callback)) {
+            throw error('Need event handler');
+        }
+        if (isArray(subjects)) {
+            subjects.forEach(subj => {
+                this.on(subj, events, callback, options);
+            });
+            return this;
+        }
+        const subject = subjects;
+        const store = this.__getStore(subject);
+        const self = this;
+        let syntheticCallback = function (event, ...args) {
+            if (self.isMuted(event)) {
+                return;
+            }
+            return callback && callback.call(this, ...args);
+        };
+        if (isDOMElement(subject)) {
+            syntheticCallback = function (event) {
+                if (self.isMuted(event.type)) {
+                    return;
+                }
+                self.__prepareEvent(event);
+                if (callback && callback.call(this, event) === false) {
+                    event.preventDefault();
+                    event.stopImmediatePropagation();
+                    return false;
+                }
+                return;
+            };
+        }
+        this.__eachEvent(events, (event, namespace) => {
+            var _a, _b;
+            if (event.length === 0) {
+                throw error('Need event name');
+            }
+            if (store.indexOf(event, namespace, callback) === false) {
+                const block = {
+                    event,
+                    originalCallback: callback,
+                    syntheticCallback
+                };
+                store.set(event, namespace, block, options === null || options === void 0 ? void 0 : options.top);
+                if (isDOMElement(subject)) {
+                    const eOpts = PASSIVE_EVENTS.has(event)
+                        ? {
+                            passive: true,
+                            capture: (_a = options === null || options === void 0 ? void 0 : options.capture) !== null && _a !== void 0 ? _a : false
+                        }
+                        : ((_b = options === null || options === void 0 ? void 0 : options.capture) !== null && _b !== void 0 ? _b : false);
+                    syntheticCallback.options = eOpts;
+                    subject.addEventListener(event, syntheticCallback, eOpts);
+                    this.__memoryDOMSubjectToHandler(subject, syntheticCallback);
+                }
+            }
+        });
+        return this;
+    }
+    __memoryDOMSubjectToHandler(subject, syntheticCallback) {
+        const callbackStore = this.__domEventsMap.get(subject) || new Set();
+        callbackStore.add(syntheticCallback);
+        this.__domEventsMap.set(subject, callbackStore);
+    }
+    __unmemoryDOMSubjectToHandler(subject, syntheticCallback) {
+        const m = this.__domEventsMap;
+        const callbackStore = m.get(subject) || new Set();
+        callbackStore.delete(syntheticCallback);
+        if (callbackStore.size) {
+            m.set(subject, callbackStore);
+        }
+        else {
+            m.delete(subject);
+        }
+    }
+    one(eventsOrSubjects, callbackOrEvents, optionsOrCallback, opts) {
+        let subjects;
+        let events;
+        let callback;
+        let options;
+        if (isString(eventsOrSubjects) || isStringArray(eventsOrSubjects)) {
+            subjects = this;
+            events = eventsOrSubjects;
+            callback = callbackOrEvents;
+            options = optionsOrCallback;
+        }
+        else {
+            subjects = eventsOrSubjects;
+            events = callbackOrEvents;
+            callback = optionsOrCallback;
+            options = opts;
+        }
+        const newCallback = (...args) => {
+            this.off(subjects, events, newCallback);
+            return callback(...args);
+        };
+        this.on(subjects, events, newCallback, options);
+        return this;
+    }
+    off(eventsOrSubjects, callbackOrEvents, handler) {
+        let subjects;
+        let events;
+        let callback;
+        if (isString(eventsOrSubjects) || isStringArray(eventsOrSubjects)) {
+            subjects = this;
+            events = eventsOrSubjects;
+            callback = callbackOrEvents;
+        }
+        else {
+            subjects = eventsOrSubjects;
+            events = callbackOrEvents;
+            callback = handler;
+        }
+        if (isArray(subjects)) {
+            subjects.forEach(subj => {
+                this.off(subj, events, callback);
+            });
+            return this;
+        }
+        const subject = subjects;
+        const store = this.__getStore(subject);
+        if (!(isString(events) || isStringArray(events)) ||
+            events.length === 0) {
+            store.namespaces().forEach((namespace) => {
+                this.off(subject, '.' + namespace);
+            });
+            this.__removeStoreFromSubject(subject);
+            return this;
+        }
+        const removeEventListener = (block) => {
+            var _a;
+            if (isDOMElement(subject)) {
+                subject.removeEventListener(block.event, block.syntheticCallback, (_a = block.syntheticCallback.options) !== null && _a !== void 0 ? _a : false);
+                this.__unmemoryDOMSubjectToHandler(subject, block.syntheticCallback);
+            }
+        }, removeCallbackFromNameSpace = (event, namespace) => {
+            if (event === '') {
+                store.events(namespace).forEach((eventName) => {
+                    if (eventName !== '') {
+                        removeCallbackFromNameSpace(eventName, namespace);
+                    }
+                });
+                return;
+            }
+            const blocks = store.get(event, namespace);
+            if (!blocks || !blocks.length) {
+                return;
+            }
+            if (!isFunction(callback)) {
+                blocks.forEach(removeEventListener);
+                blocks.length = 0;
+                store.clearEvents(namespace, event);
+            }
+            else {
+                const index = store.indexOf(event, namespace, callback);
+                if (index !== false) {
+                    removeEventListener(blocks[index]);
+                    blocks.splice(index, 1);
+                    if (!blocks.length) {
+                        store.clearEvents(namespace, event);
+                    }
+                }
+            }
+        };
+        this.__eachEvent(events, (event, namespace) => {
+            if (namespace === defaultNameSpace) {
+                store.namespaces().forEach(namespace => {
+                    removeCallbackFromNameSpace(event, namespace);
+                });
+            }
+            else {
+                removeCallbackFromNameSpace(event, namespace);
+            }
+        });
+        if (store.isEmpty()) {
+            this.__removeStoreFromSubject(subject);
+        }
+        return this;
+    }
+    stopPropagation(subjectOrEvents, eventsList) {
+        const subject = isString(subjectOrEvents)
+            ? this
+            : subjectOrEvents;
+        const events = isString(subjectOrEvents)
+            ? subjectOrEvents
+            : eventsList;
+        if (typeof events !== 'string') {
+            throw error('Need event names');
+        }
+        const store = this.__getStore(subject);
+        this.__eachEvent(events, (event, namespace) => {
+            const blocks = store.get(event, namespace);
+            if (blocks) {
+                this.__stopped.push(blocks);
+            }
+            if (namespace === defaultNameSpace) {
+                store
+                    .namespaces(true)
+                    .forEach(ns => this.stopPropagation(subject, event + '.' + ns));
+            }
+        });
+    }
+    __removeStop(currentBlocks) {
+        if (currentBlocks) {
+            const index = this.__stopped.indexOf(currentBlocks);
+            index !== -1 && this.__stopped.splice(0, index + 1);
+        }
+    }
+    __isStopped(currentBlocks) {
+        return (currentBlocks !== undefined &&
+            this.__stopped.indexOf(currentBlocks) !== -1);
+    }
+    fire(subjectOrEvents, eventsList, ...args) {
+        let result, result_value;
+        const subject = isString(subjectOrEvents)
+            ? this
+            : subjectOrEvents;
+        const events = isString(subjectOrEvents)
+            ? subjectOrEvents
+            : eventsList;
+        const argumentsList = isString(subjectOrEvents)
+            ? [eventsList, ...args]
+            : args;
+        if (!isDOMElement(subject) && !isString(events)) {
+            throw error('Need events names');
+        }
+        const store = this.__getStore(subject);
+        if (!isString(events) && isDOMElement(subject)) {
+            this.__triggerNativeEvent(subject, eventsList);
+        }
+        else {
+            this.__eachEvent(events, (event, namespace) => {
+                if (isDOMElement(subject)) {
+                    this.__triggerNativeEvent(subject, event);
+                }
+                else {
+                    const blocks = store.get(event, namespace);
+                    if (blocks) {
+                        try {
+                            [...blocks].every((block) => {
+                                if (this.__isStopped(blocks)) {
+                                    return false;
+                                }
+                                this.currents.push(event);
+                                result_value =
+                                    block.syntheticCallback.call(subject, event, ...argumentsList);
+                                this.currents.pop();
+                                if (result_value !== undefined) {
+                                    result = result_value;
+                                }
+                                return true;
+                            });
+                        }
+                        finally {
+                            this.__removeStop(blocks);
+                        }
+                    }
+                    if (namespace === defaultNameSpace &&
+                        !isDOMElement(subject)) {
+                        store
+                            .namespaces()
+                            .filter(ns => ns !== namespace)
+                            .forEach((ns) => {
+                            const result_second = this.fire.apply(this, [
+                                subject,
+                                event + '.' + ns,
+                                ...argumentsList
+                            ]);
+                            if (result_second !== undefined) {
+                                result = result_second;
+                            }
+                        });
+                    }
+                }
+            });
+        }
+        return result;
+    }
+    constructor(doc) {
+        this.__domEventsMap = new Map();
+        this.__mutedEvents = new Set();
+        this.__key = '__JoditEventEmitterNamespaces';
+        this.__doc = globalDocument;
+        this.__prepareEvent = (e) => {
+            if (e.cancelBubble) {
+                return;
+            }
+            // for Shadow Dom
+            if (e.composed && isFunction(e.composedPath) && e.composedPath()[0]) {
+                Object.defineProperty(e, 'target', {
+                    value: e.composedPath()[0],
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+            if (e.type.match(/^touch/) &&
+                e.changedTouches &&
+                e.changedTouches.length) {
+                ['clientX', 'clientY', 'pageX', 'pageY'].forEach((key) => {
+                    Object.defineProperty(e, key, {
+                        value: e.changedTouches[0][key],
+                        configurable: true,
+                        enumerable: true
+                    });
+                });
+            }
+            if (!e.originalEvent) {
+                e.originalEvent = e;
+            }
+            if (e.type === 'paste' &&
+                e.clipboardData === undefined &&
+                this.__doc.defaultView.clipboardData) {
+                Object.defineProperty(e, 'clipboardData', {
+                    get: () => {
+                        return this.__doc.defaultView.clipboardData;
+                    },
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+        };
+        this.currents = [];
+        this.__stopped = [];
+        this.__isDestructed = false;
+        if (doc) {
+            this.__doc = doc;
+        }
+        this.__key += new Date().getTime();
+    }
+    destruct() {
+        if (this.__isDestructed) {
+            return;
+        }
+        this.__isDestructed = true;
+        this.__domEventsMap.forEach((set, elm) => {
+            this.off(elm);
+        });
+        this.__domEventsMap.clear();
+        this.__mutedEvents.clear();
+        this.currents.length = 0;
+        this.__stopped.length = 0;
+        this.off(this);
+        this.__getStore(this).clear();
+        this.__removeStoreFromSubject(this);
+    }
+}
+function isDOMElement(subject) {
+    return isFunction(subject.addEventListener);
+}

node_modules/jodit/esm/core/event-emitter/eventify.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module event-emitter
+ */
+import type { CanUndef, IDestructible } from "../../types/index";
+/**
+ * Class for adding event handling capability
+ *
+ * ```ts
+ * class SomeClass extends Eventify<{ start: (node: Node) => boolean; }> {
+ * 	constructor() {
+ * 		super();
+ * 		setTimeout(() => {
+ * 			if (this.emit('start', document.body)) {
+ * 				console.log('yes');
+ * 			};
+ * 		}, 100);
+ * 	}
+ * }
+ *
+ * const sm = new SomeClass();
+ * sm.on('start', (node) => {
+ * 	console.log(node);
+ * 	return true;
+ * })
+ * ```
+ */
+export declare abstract class Eventify<MAP extends {
+    [key: string]: (...args: any[]) => any;
+}, EVENT extends keyof MAP = keyof MAP> implements IDestructible {
+    private __map;
+    on(name: EVENT, func: MAP[EVENT]): this;
+    off(name: keyof MAP, func: MAP[EVENT]): this;
+    destruct(): void;
+    protected emit(name: EVENT, ...args: Parameters<MAP[EVENT]>): CanUndef<ReturnType<MAP[EVENT]>>;
+}

node_modules/jodit/esm/core/event-emitter/eventify.js

@@ -0,0 +1,60 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * Class for adding event handling capability
+ *
+ * ```ts
+ * class SomeClass extends Eventify<{ start: (node: Node) => boolean; }> {
+ * 	constructor() {
+ * 		super();
+ * 		setTimeout(() => {
+ * 			if (this.emit('start', document.body)) {
+ * 				console.log('yes');
+ * 			};
+ * 		}, 100);
+ * 	}
+ * }
+ *
+ * const sm = new SomeClass();
+ * sm.on('start', (node) => {
+ * 	console.log(node);
+ * 	return true;
+ * })
+ * ```
+ */
+export class Eventify {
+    constructor() {
+        this.__map = new Map();
+    }
+    on(name, func) {
+        var _a;
+        if (!this.__map.has(name)) {
+            this.__map.set(name, new Set());
+        }
+        (_a = this.__map.get(name)) === null || _a === void 0 ? void 0 : _a.add(func);
+        return this;
+    }
+    off(name, func) {
+        var _a;
+        if (this.__map.has(name)) {
+            (_a = this.__map.get(name)) === null || _a === void 0 ? void 0 : _a.delete(func);
+        }
+        return this;
+    }
+    destruct() {
+        this.__map.clear();
+    }
+    emit(name, ...args) {
+        var _a;
+        let result;
+        if (this.__map.has(name)) {
+            (_a = this.__map.get(name)) === null || _a === void 0 ? void 0 : _a.forEach(cb => {
+                result = cb(...args);
+            });
+        }
+        return result;
+    }
+}

node_modules/jodit/esm/core/event-emitter/index.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module event-emitter
+ */
+export * from "./event-emitter";
+export * from "./eventify";
+export * from "./observable";
+export * from "./store";

node_modules/jodit/esm/core/event-emitter/index.js

@@ -0,0 +1,12 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module event-emitter
+ */
+export * from "./event-emitter.js";
+export * from "./eventify.js";
+export * from "./observable.js";
+export * from "./store.js";

node_modules/jodit/esm/core/event-emitter/observable.d.ts

@@ -0,0 +1,45 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module event-emitter
+ */
+import type { IDictionary, IObservable } from "../../types/index";
+/**
+ * Makes any object an observable object
+ * @example
+ * ```js
+ * const obj = {
+ *   a: 1,
+ *   b: {
+ *     c: 5
+ *   }
+ * }
+ *
+ * const obsObj = Jodit.modules.observable(obj);
+ * console.log(obj === obsObj); // true
+ * obsObj.on('change', () => {
+ *   console.log('Object changed');
+ * });
+ * obsObj.on('change.a', () => {
+ *   console.log('Key a changed');
+ * });
+ * obsObj.on('change.b.c', () => {
+ *   console.log('Key b.c changed');
+ * });
+ *
+ * obj.a = 6;
+ * // Object changed
+ * // Key a changed
+ *
+ * obj.b = {c: 6}
+ * // Object changed
+ *
+ * obj.b.c = 8
+ * // Object changed
+ * // Key b.c changed
+ * ```
+ */
+export declare function observable<T extends IDictionary, O extends T & IObservable>(obj: T): O;

node_modules/jodit/esm/core/event-emitter/observable.js

@@ -0,0 +1,144 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+import { getPropertyDescriptor } from "../decorators/watch/watch.js";
+import { isArray } from "../helpers/checker/is-array.js";
+import { isFastEqual } from "../helpers/checker/is-equal.js";
+import { isPlainObject } from "../helpers/checker/is-plain-object.js";
+const OBSERVABLE_OBJECT = Symbol('observable-object');
+function isObservableObject(obj) {
+    return obj[OBSERVABLE_OBJECT] !== undefined;
+}
+/**
+ * Makes any object an observable object
+ * @example
+ * ```js
+ * const obj = {
+ *   a: 1,
+ *   b: {
+ *     c: 5
+ *   }
+ * }
+ *
+ * const obsObj = Jodit.modules.observable(obj);
+ * console.log(obj === obsObj); // true
+ * obsObj.on('change', () => {
+ *   console.log('Object changed');
+ * });
+ * obsObj.on('change.a', () => {
+ *   console.log('Key a changed');
+ * });
+ * obsObj.on('change.b.c', () => {
+ *   console.log('Key b.c changed');
+ * });
+ *
+ * obj.a = 6;
+ * // Object changed
+ * // Key a changed
+ *
+ * obj.b = {c: 6}
+ * // Object changed
+ *
+ * obj.b.c = 8
+ * // Object changed
+ * // Key b.c changed
+ * ```
+ */
+export function observable(obj) {
+    if (isObservableObject(obj)) {
+        return obj;
+    }
+    const __lockEvent = {};
+    const __onEvents = {};
+    const on = (event, callback) => {
+        if (isArray(event)) {
+            event.map(e => on(e, callback));
+            return obj;
+        }
+        if (!__onEvents[event]) {
+            __onEvents[event] = [];
+        }
+        __onEvents[event].push(callback);
+        return obj;
+    };
+    const fire = (event, ...attr) => {
+        if (isArray(event)) {
+            event.map(e => fire(e, ...attr));
+            return;
+        }
+        try {
+            if (!__lockEvent[event] && __onEvents[event]) {
+                __lockEvent[event] = true;
+                __onEvents[event].forEach(clb => clb.call(obj, ...attr));
+            }
+        }
+        finally {
+            __lockEvent[event] = false;
+        }
+    };
+    const initAccessors = (dict, prefixes = []) => {
+        const store = {};
+        if (isObservableObject(dict)) {
+            return;
+        }
+        Object.defineProperty(dict, OBSERVABLE_OBJECT, {
+            enumerable: false,
+            value: true
+        });
+        Object.keys(dict).forEach(_key => {
+            const key = _key;
+            const prefix = prefixes.concat(key).filter(a => a.length);
+            store[key] = dict[key];
+            const descriptor = getPropertyDescriptor(dict, key);
+            Object.defineProperty(dict, key, {
+                set: (value) => {
+                    const oldValue = store[key];
+                    if (!isFastEqual(store[key], value)) {
+                        fire([
+                            'beforeChange',
+                            `beforeChange.${prefix.join('.')}`
+                        ], key, value);
+                        if (isPlainObject(value)) {
+                            initAccessors(value, prefix);
+                        }
+                        if (descriptor && descriptor.set) {
+                            descriptor.set.call(obj, value);
+                        }
+                        else {
+                            store[key] = value;
+                        }
+                        const sum = [];
+                        fire([
+                            'change',
+                            ...prefix.reduce((rs, p) => {
+                                sum.push(p);
+                                rs.push(`change.${sum.join('.')}`);
+                                return rs;
+                            }, [])
+                        ], prefix.join('.'), oldValue, (value === null || value === void 0 ? void 0 : value.valueOf)
+                            ? value.valueOf()
+                            : value);
+                    }
+                },
+                get: () => {
+                    if (descriptor && descriptor.get) {
+                        return descriptor.get.call(obj);
+                    }
+                    return store[key];
+                },
+                enumerable: true,
+                configurable: true
+            });
+            if (isPlainObject(store[key])) {
+                initAccessors(store[key], prefix);
+            }
+        });
+        Object.defineProperty(obj, 'on', {
+            value: on
+        });
+    };
+    initAccessors(obj);
+    return obj;
+}

node_modules/jodit/esm/core/event-emitter/store.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module event-emitter
+ */
+import type { CallbackFunction, EventHandlerBlock } from "../../types/index";
+export declare const defaultNameSpace = "JoditEventDefaultNamespace";
+export declare class EventHandlersStore {
+    private __store;
+    get(event: string, namespace: string): EventHandlerBlock[] | void;
+    indexOf(event: string, namespace: string, originalCallback: CallbackFunction): false | number;
+    namespaces(withoutDefault?: boolean): string[];
+    events(namespace: string): string[];
+    set(event: string, namespace: string, data: EventHandlerBlock, onTop?: boolean): void;
+    clear(): void;
+    clearEvents(namespace: string, event: string): void;
+    isEmpty(): boolean;
+}

node_modules/jodit/esm/core/event-emitter/store.js

@@ -0,0 +1,70 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+import { toArray } from "../helpers/array/to-array.js";
+import { assert } from "../helpers/utils/assert.js";
+export const defaultNameSpace = 'JoditEventDefaultNamespace';
+export class EventHandlersStore {
+    constructor() {
+        this.__store = new Map();
+    }
+    get(event, namespace) {
+        if (this.__store.has(namespace)) {
+            const ns = this.__store.get(namespace);
+            assert(ns, '-');
+            return ns[event];
+        }
+    }
+    indexOf(event, namespace, originalCallback) {
+        const blocks = this.get(event, namespace);
+        if (blocks) {
+            for (let i = 0; i < blocks.length; i += 1) {
+                if (blocks[i].originalCallback === originalCallback) {
+                    return i;
+                }
+            }
+        }
+        return false;
+    }
+    namespaces(withoutDefault = false) {
+        const nss = toArray(this.__store.keys());
+        return withoutDefault ? nss.filter(ns => ns !== defaultNameSpace) : nss;
+    }
+    events(namespace) {
+        const ns = this.__store.get(namespace);
+        return ns ? Object.keys(ns) : [];
+    }
+    set(event, namespace, data, onTop = false) {
+        let ns = this.__store.get(namespace);
+        if (!ns) {
+            ns = {};
+            this.__store.set(namespace, ns);
+        }
+        if (ns[event] === undefined) {
+            ns[event] = [];
+        }
+        if (!onTop) {
+            ns[event].push(data);
+        }
+        else {
+            ns[event].unshift(data);
+        }
+    }
+    clear() {
+        this.__store.clear();
+    }
+    clearEvents(namespace, event) {
+        const ns = this.__store.get(namespace);
+        if (ns && ns[event]) {
+            delete ns[event];
+            if (!Object.keys(ns).length) {
+                this.__store.delete(namespace);
+            }
+        }
+    }
+    isEmpty() {
+        return this.__store.size === 0;
+    }
+}