@plohoj/html-editor 0.0.6 → 0.1.0

package/dist/index.js

@@ -1,5 +1,73 @@
-import { throttleTime, mergeMap, distinctUntilChanged, switchMap, debounceTime, filter, map, take, tap, shareReplay, connect, takeUntil } from 'rxjs/operators';
-import { Observable, concat, defer, EMPTY, of, merge, fromEvent, pipe, from, tap as tap$1, share, NEVER, takeUntil as takeUntil$1, ignoreElements, ReplaySubject } from 'rxjs';
+import { mergeMap, EMPTY, merge, connect, filter, takeUntil, Observable, concat, defer, throttleTime, distinctUntilChanged, switchMap, of, debounceTime, map, take, fromEvent, tap, shareReplay, share, NEVER, ignoreElements, ReplaySubject } from 'rxjs';
+import { __rest } from 'tslib';
+
+function assuredArray(values) {
+    if (values instanceof Array) {
+        return values;
+    }
+    if (values) {
+        return [values];
+    }
+    return [];
+}
+function mergeMapAddedElements(projectOrOptions, options) {
+    // #region Options parsing
+    let project;
+    let stableOptions;
+    if (typeof projectOrOptions === 'function') {
+        project = projectOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        project = projectOrOptions.project;
+        stableOptions = projectOrOptions;
+    }
+    const { takeUntil: takeUntilOption = 'removed' } = stableOptions;
+    // #endregion
+    if (takeUntilOption === 'always') {
+        return source$ => source$.pipe(mergeMap(changes => {
+            const added = assuredArray(changes.added);
+            if (added.length === 0) {
+                return EMPTY;
+            }
+            const addedObservers = added.map(project);
+            return merge(...addedObservers);
+        }));
+    }
+    return source$ => source$.pipe(connect(connectedSource$ => connectedSource$.pipe(mergeMap(changes => {
+        const added = assuredArray(changes.added);
+        if (added.length === 0) {
+            return EMPTY;
+        }
+        const addedObservers = added.map(addedElement => {
+            let takeUntil$;
+            if (takeUntilOption === 'removed') {
+                takeUntil$ = connectedSource$.pipe(filter(connectedChanges => connectedChanges.removed instanceof Array
+                    ? connectedChanges.removed.indexOf(addedElement) !== -1
+                    : connectedChanges.removed === addedElement));
+            }
+            else {
+                let wasRemoved = false;
+                takeUntil$ = connectedSource$.pipe(filter(connectedChanges => {
+                    if (!wasRemoved) {
+                        wasRemoved = connectedChanges.removed instanceof Array
+                            ? connectedChanges.removed.indexOf(addedElement) !== -1
+                            : connectedChanges.removed === addedElement;
+                    }
+                    if (wasRemoved) {
+                        const hasTarget = connectedChanges.target instanceof Array
+                            ? connectedChanges.target.indexOf(addedElement) !== -1
+                            : connectedChanges.target === addedElement;
+                        return hasTarget;
+                    }
+                    return false;
+                }));
+            }
+            return project(addedElement).pipe(takeUntil(takeUntil$));
+        });
+        return merge(...addedObservers);
+    }))));
+}
 
 function trueStub() {
     return true;
@@ -8,9 +76,7 @@ function falseStub() {
     return false;
 }
 
-/**
- * Converts the callback of the MutationObserver class to an Rx event stream
- */
+/** Converts the callback of the {@link MutationObserver} class to an Rx event stream */
 function observeElementMutation(node, options) {
     return new Observable(subscriber => {
         const mutationObserver = new MutationObserver(mutation => subscriber.next(mutation));
@@ -19,18 +85,36 @@ function observeElementMutation(node, options) {
     });
 }
 
-/**
- * Returns change (addition and deletion) of element that match selectors, like an Rx stream.
- */
-function observeQuerySelector(query, options = {}) {
-    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, } = options;
+function observeQuerySelector(queryOrOptions, projectOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let project;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        if (typeof projectOrOptions === 'function') {
+            project = projectOrOptions;
+            stableOptions = options || {};
+        }
+        else {
+            stableOptions = projectOrOptions || {};
+            project = projectOrOptions === null || projectOrOptions === void 0 ? void 0 : projectOrOptions.project;
+        }
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+        project = queryOrOptions === null || queryOrOptions === void 0 ? void 0 : queryOrOptions.project;
+    }
+    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, has, tap } = stableOptions, restOfStableOptions = __rest(stableOptions, ["parent", "asRemovedWhen", "filter", "has", "tap"]);
+    // #endregion
     let targetElement;
     function checkChanges() {
         const querySelectedElements = parent.querySelectorAll(query);
         let filteredSelectedElement;
         const changes = {};
         for (const querySelectedElement of querySelectedElements) {
-            if (options.has && !querySelectedElement.querySelector(options.has)) {
+            if (has && !querySelectedElement.querySelector(has)) {
                 continue;
             }
             if (!filter(querySelectedElement)) {
@@ -47,12 +131,14 @@ function observeQuerySelector(query, options = {}) {
         }
         if (filteredSelectedElement) {
             changes.added = filteredSelectedElement;
+            tap === null || tap === void 0 ? void 0 : tap(filteredSelectedElement);
         }
         changes.target = filteredSelectedElement;
         targetElement = filteredSelectedElement;
         return of(changes);
     }
     const observeQuerySelector$ = concat(defer(() => checkChanges()), observeElementMutation(parent, { subtree: true, childList: true }).pipe(throttleTime(0, undefined, { leading: true, trailing: true }), mergeMap(checkChanges)));
+    let observeQuerySelectorWithRemovedWhen$ = observeQuerySelector$;
     if (asRemovedWhen) {
         const removedObserver$ = defer(() => {
             if (!targetElement) {
@@ -64,38 +150,60 @@ function observeQuerySelector(query, options = {}) {
             targetElement = undefined;
             return of(changes);
         });
-        const observeQuerySelectorWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelector$));
-        return observeQuerySelectorWithRemovedWhen$;
+        observeQuerySelectorWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelector$));
     }
-    return observeQuerySelector$;
-}
-
-/**
- * Awaiting only one element to match the selector and returns it as an Rx stream.
- * The stream ends after one element is found / added.
- */
-function awaitElement(query, options = {}) {
-    return observeQuerySelector(query, options)
-        .pipe(debounceTime(options.debounceTime || 0, options.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
+    if (project) {
+        return observeQuerySelectorWithRemovedWhen$.pipe(mergeMapAddedElements(Object.assign({ project }, restOfStableOptions)));
+    }
+    return observeQuerySelectorWithRemovedWhen$;
 }
 
-function randomFromArray(array, from = 0, to = array.length) {
-    if (to < 0) {
-        to = array.length + to;
+function awaitElement(queryOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        stableOptions = options || {};
     }
-    return array[Math.floor(Math.random() * (to - from)) + from];
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+    }
+    // #endregion
+    return observeQuerySelector(query, stableOptions).pipe(debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
 }
 
-/** Returns changes (additions and deletions) of elements that match selectors, like an Rx stream. */
-function observeQuerySelectorAll(query, options = {}) {
-    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, } = options;
+function observeQuerySelectorAll(queryOrOptions, projectOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let project;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        if (typeof projectOrOptions === 'function') {
+            project = projectOrOptions;
+            stableOptions = options || {};
+        }
+        else {
+            stableOptions = projectOrOptions || {};
+            project = projectOrOptions === null || projectOrOptions === void 0 ? void 0 : projectOrOptions.project;
+        }
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+        project = queryOrOptions === null || queryOrOptions === void 0 ? void 0 : queryOrOptions.project;
+    }
+    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, has, tap } = stableOptions, restOfStableOptions = __rest(stableOptions, ["parent", "asRemovedWhen", "filter", "has", "tap"]);
+    // #endregion
     const targetElements = new Set();
     function checkChanges() {
         const addedElements = new Set();
         const targetElementsDiff = new Set(targetElements);
         const querySelectedElements = new Set(parent.querySelectorAll(query));
         for (const querySelectedElement of querySelectedElements) {
-            if (options.has && !querySelectedElement.querySelector(options.has)) {
+            if (has && !querySelectedElement.querySelector(has)) {
                 continue;
             }
             if (!filter(querySelectedElement)) {
@@ -117,6 +225,7 @@ function observeQuerySelectorAll(query, options = {}) {
         }
         for (const addedElement of addedElements) {
             targetElements.add(addedElement);
+            tap === null || tap === void 0 ? void 0 : tap(addedElement);
         }
         const changes = {
             target: [...targetElements.values()],
@@ -125,7 +234,8 @@ function observeQuerySelectorAll(query, options = {}) {
         };
         return of(changes);
     }
-    let observeQuerySelectorAll$ = concat(defer(() => checkChanges()), observeElementMutation(parent, { subtree: true, childList: true }).pipe(throttleTime(0, undefined, { leading: true, trailing: true }), mergeMap(checkChanges)));
+    const observeQuerySelectorAll$ = concat(defer(() => checkChanges()), observeElementMutation(parent, { subtree: true, childList: true }).pipe(throttleTime(0, undefined, { leading: true, trailing: true }), mergeMap(checkChanges)));
+    let observeQuerySelectorAllWithRemovedWhen$ = observeQuerySelectorAll$;
     if (asRemovedWhen) {
         const removedObserver$ = defer(() => {
             if (targetElements.size === 0) {
@@ -139,28 +249,58 @@ function observeQuerySelectorAll(query, options = {}) {
             targetElements.clear();
             return of(changes);
         });
-        const observeQuerySelectorAllWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelectorAll$));
-        return observeQuerySelectorAllWithRemovedWhen$;
+        observeQuerySelectorAllWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelectorAll$));
+    }
+    if (project) {
+        return observeQuerySelectorAllWithRemovedWhen$.pipe(mergeMapAddedElements(Object.assign({ project }, restOfStableOptions)));
     }
-    return observeQuerySelectorAll$;
+    return observeQuerySelectorAllWithRemovedWhen$;
 }
 
-/**
- * Awaiting Expects at least one element to match the selector and returns it as an Rx stream.
- * If there are more than 1 elements, it will return a random one.
- * The stream ends after the elements are found / added.
- */
-function awaitRandomElement(query, options = {}) {
-    return observeQuerySelectorAll(query, options)
-        .pipe(debounceTime(options.debounceTime || 0, options.debounceScheduler), filter(changes => changes.target.length > 0), map(changes => randomFromArray(changes.target)), take(1));
+function awaitElements(queryOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+    }
+    // #endregion
+    return observeQuerySelectorAll(query, stableOptions).pipe(debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
+}
+
+function randomFromArray(array, from = 0, to = array.length) {
+    if (to < 0) {
+        to = array.length + to;
+    }
+    return array[Math.floor(Math.random() * (to - from)) + from];
+}
+
+function awaitRandomElement(queryOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+    }
+    // #endregion
+    return observeQuerySelectorAll(query, stableOptions).pipe(debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler), filter(changes => changes.target.length > 0), map(changes => randomFromArray(changes.target)), take(1));
 }
 
 function observePressedKeyboardButtons(options = {}) {
     const target = options.target || window;
     const set = new Set();
     const addKey$ = merge(fromEvent(target, 'keydown'), fromEvent(target, 'keypress')).pipe(filter((event) => !set.has(event.key)), tap((event) => set.add(event.key)));
-    const keyRemove$ = fromEvent(target, 'keyup')
-        .pipe(filter((event) => set.has(event.key)), tap((event) => set.delete(event.key)));
+    const keyRemove$ = fromEvent(target, 'keyup').pipe(filter((event) => set.has(event.key)), tap((event) => set.delete(event.key)));
     return merge(addKey$, keyRemove$).pipe(map(() => set));
 }
 
@@ -191,8 +331,89 @@ const urlChange$ = new Observable(subscriber$ => {
     };
 }).pipe(distinctUntilChanged(), shareReplay(1));
 
+function mergeMapByCondition(conditionOrOptions, project, options) {
+    // #region Options parsing
+    let stableOptions;
+    let conditionFn;
+    let stableProject;
+    if ('condition' in conditionOrOptions) {
+        stableOptions = conditionOrOptions;
+        conditionFn = conditionOrOptions.condition;
+        stableProject = conditionOrOptions.project;
+    }
+    else {
+        conditionFn = conditionOrOptions;
+        stableOptions = options || {};
+        stableProject = project;
+    }
+    const { takeFor = 'new', takeUntil: takeUntilOption = 'fail', } = stableOptions;
+    // #endregion
+    let isPrevConditionPass = false;
+    return source$ => source$.pipe(map(source => ({ source, isConditionPassed: conditionFn(source) })), connect(connectedSource$ => {
+        let takeUntil$;
+        if (takeUntilOption === 'fail') {
+            takeUntil$ = connectedSource$.pipe(filter(({ isConditionPassed }) => isConditionPassed));
+        }
+        else if (takeUntilOption === 'pass') {
+            let wasFailed = false;
+            takeUntil$ = connectedSource$.pipe(filter(({ isConditionPassed }) => {
+                if (isConditionPassed) {
+                    if (wasFailed) {
+                        return true;
+                    }
+                }
+                else {
+                    wasFailed = true;
+                }
+                return false;
+            }));
+        }
+        return connectedSource$.pipe(mergeMap(({ source, isConditionPassed }) => {
+            if (isConditionPassed) {
+                const isCreateNewProject = takeFor === 'all' || !isPrevConditionPass;
+                isPrevConditionPass = true;
+                if (isCreateNewProject) {
+                    if (!stableProject) {
+                        return of(source);
+                    }
+                    let project$ = stableProject(source);
+                    if (takeUntil$) {
+                        project$ = project$.pipe(takeUntil(takeUntil$));
+                    }
+                    return project$;
+                }
+            }
+            else {
+                isPrevConditionPass = false;
+            }
+            return EMPTY;
+        }));
+    }));
+}
+
+function getStringConditionFunction(condition) {
+    return typeof condition === 'function' ? condition : (value) => condition.test(value);
+}
+function mergeMapStringCondition(conditionOrOptions, project, options) {
+    if ('condition' in conditionOrOptions) {
+        return mergeMapByCondition(Object.assign(Object.assign({}, conditionOrOptions), { condition: getStringConditionFunction(conditionOrOptions.condition) }));
+    }
+    else {
+        return mergeMapByCondition(Object.assign(Object.assign({}, options), { condition: getStringConditionFunction(conditionOrOptions), project }));
+    }
+}
+
+function observeUrlChanges(options = {}) {
+    return urlChange$.pipe(mergeMapStringCondition(Object.assign(Object.assign({}, options), { condition: options.condition || (() => true) })));
+}
+
 function clickElementImmediately(element) {
-    element.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    if ('click' in element) {
+        element.click();
+    }
+    else {
+        element.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    }
     console.log(`Click: `, element);
 }
 function clickElement(element) {
@@ -200,73 +421,34 @@ function clickElement(element) {
         clickElementImmediately(element);
     }
     else {
-        return pipe(tap((element) => clickElementImmediately(element)));
+        return tap((element) => clickElementImmediately(element));
     }
 }
 
-function assuredArray(values) {
-    if (values instanceof Array) {
-        return values;
+function focusElementImmediately(element) {
+    if ('focus' in element) {
+        element.focus();
     }
-    if (values) {
-        return [values];
+    else {
+        element.dispatchEvent(new FocusEvent('focus'));
+        element.dispatchEvent(new FocusEvent('focusin', { bubbles: true }));
     }
-    return [];
+    console.log(`Focus: `, element);
 }
-function mergeMapAddedElements(projectOrOptions, options) {
-    const project = typeof projectOrOptions === 'function'
-        ? projectOrOptions
-        : (element) => of(element);
-    options = typeof projectOrOptions === 'object' ? projectOrOptions : options;
-    const { isTakeUntilRemoved = false } = options || {};
-    if (!isTakeUntilRemoved) {
-        return source$ => source$.pipe(mergeMap(changes => {
-            const added = assuredArray(changes.added);
-            if (added.length === 0) {
-                return EMPTY;
-            }
-            const addedObservers = added.map(project);
-            return merge(...addedObservers);
-        }));
-    }
-    return source$ => source$.pipe(connect(connectedSource$ => connectedSource$.pipe(mergeMap(changes => {
-        const added = assuredArray(changes.added);
-        if (added.length === 0) {
-            return EMPTY;
-        }
-        const addedObservers = added.map(addedElement => from(project(addedElement)).pipe(takeUntil(connectedSource$.pipe(filter(changes => {
-            if (changes.removed instanceof Array) {
-                return changes.removed.indexOf(addedElement) != -1;
-            }
-            else {
-                return changes.removed === addedElement;
-            }
-        })))));
-        return merge(...addedObservers);
-    }))));
-}
-
-/** The operator creates a separate stream when the source string is validated. */
-function mergeMapStringToggle(condition, project, options) {
-    const mapConditionFn = typeof condition === 'function' ? condition : (url) => condition.test(url);
-    let urlMatchToggler;
-    if (typeof project === 'function') {
-        urlMatchToggler = (isUrlMatch) => isUrlMatch ? from(project()) : EMPTY;
+function focusElement(element) {
+    if (element) {
+        focusElementImmediately(element);
     }
     else {
-        urlMatchToggler = (isUrlMatch) => isUrlMatch ? from(project) : EMPTY;
+        return tap((element) => focusElementImmediately(element));
     }
-    const mergeOperator = (options === null || options === void 0 ? void 0 : options.isTakeUntilToggle)
-        ? switchMap(urlMatchToggler)
-        : mergeMap(urlMatchToggler);
-    return pipe(map(mapConditionFn), distinctUntilChanged(), mergeOperator);
 }
 
 function removeElement() {
-    return pipe(tap((element) => {
+    return tap((element) => {
         element.remove();
         console.log(`Remove: `, element);
-    }));
+    });
 }
 
 function restoreHistory(options) {
@@ -274,7 +456,7 @@ function restoreHistory(options) {
         let hasStory = false;
         const observeCancel$ = options.cancelRestore
             ? defer(() => options.cancelRestore())
-                .pipe(tap$1(() => {
+                .pipe(tap(() => {
                 if (hasStory) {
                     options.removeStory();
                 }
@@ -288,10 +470,10 @@ function restoreHistory(options) {
             hasStory = true;
             let rested$ = of(story);
             if (options.cancelRestore) {
-                rested$ = rested$.pipe(takeUntil$1(observeCancel$));
+                rested$ = rested$.pipe(takeUntil(observeCancel$));
             }
             return rested$;
-        }), source$.pipe(tap$1((data) => {
+        }), source$.pipe(tap((data) => {
             options.setStory(data);
             hasStory = true;
         })));
@@ -302,12 +484,12 @@ function restoreHistory(options) {
 function setInputValueImmediately(element, value) {
     element.value = value;
     element.focus();
-    element.dispatchEvent(new Event('input', { target: element }));
+    element.dispatchEvent(new Event('input'));
     console.log(`Set value: `, { element, value });
 }
 function setInputValue(elementOrValue, value) {
     if (typeof elementOrValue === 'string') {
-        return pipe(tap((element) => setInputValueImmediately(element, elementOrValue)));
+        return tap((element) => setInputValueImmediately(element, elementOrValue));
     }
     else {
         setInputValueImmediately(elementOrValue, value);
@@ -349,6 +531,7 @@ function findRecursively(obj, options = {}) {
     const needSeen = new Set([{
             value: obj,
             depth: 0,
+            path: '',
         }]);
     const { matcher = falseStub, filter = trueStub, continueAfterGetterError = trueStub, stop = falseStub, minDepth = 1, maxDepth = Infinity, } = options;
     const pathRegExpCheck = options.pathRegExp
@@ -368,7 +551,7 @@ function findRecursively(obj, options = {}) {
             if (seenPathsForValue) {
                 // TODO windows or document
                 // TODO List of visited objects, but with the wrong path
-                const hasCircularPath = seenPathsForValue.some(path => options.path && (path === null || path === void 0 ? void 0 : path.includes(options.path)));
+                const hasCircularPath = seenPathsForValue.some(path => options.path.includes(path));
                 if (hasCircularPath) {
                     return;
                 }
@@ -415,12 +598,12 @@ function findRecursively(obj, options = {}) {
         const incrementalDepth = depth + 1;
         needSeen.delete(iterator.value);
         if (value instanceof Array) {
-            iterateArrayLike(value.entries(), (fieldIndex) => `${path || ''}[${fieldIndex}]`, incrementalDepth);
+            iterateArrayLike(value.entries(), (fieldIndex) => `${path}[${fieldIndex}]`, incrementalDepth);
         }
-        if (value instanceof Map) {
-            iterateArrayLike(value.entries(), (fieldIndex) => `${path || ''}{${fieldIndex}}`, incrementalDepth);
+        else if (value instanceof Map) {
+            iterateArrayLike(value.entries(), (fieldIndex) => `${path}{${fieldIndex}}`, incrementalDepth);
         }
-        if (value instanceof Set) {
+        else if (value instanceof Set) {
             for (const [fieldIndex, fieldValue] of [...value].entries()) {
                 checkForNeedSeen({
                     field: fieldValue,
@@ -467,5 +650,5 @@ function findRecursively(obj, options = {}) {
     return searched;
 }
 
-export { awaitElement, awaitRandomElement, clickElement, composeRestoreHistory, findRecursively, mergeMapAddedElements, mergeMapStringToggle, observeElementMutation, observePressedKeyboardButtons, observeQuerySelector, observeQuerySelectorAll, randomFromArray, removeElement, restoreHistory, setInputValue, urlChange$ };
+export { awaitElement, awaitElements, awaitRandomElement, clickElement, composeRestoreHistory, findRecursively, focusElement, mergeMapAddedElements, mergeMapByCondition, mergeMapStringCondition, observeElementMutation, observePressedKeyboardButtons, observeQuerySelector, observeQuerySelectorAll, observeUrlChanges, randomFromArray, removeElement, restoreHistory, setInputValue, urlChange$ };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,24 +1,25 @@
-{
-  "name": "@plohoj/html-editor",
-  "version": "0.0.6",
-  "description": "html-editor it's a tool for helping modification html elements",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/plohoj/html-editor.git"
-  },
-  "scripts": {
-    "build": "rollup --config"
-  },
-  "author": "Plokhikh Alexandr",
-  "license": "ISC",
-  "module": "./dist/index.js",
-  "types": "./src/index.ts",
-  "dependencies": {
-    "rxjs": "^7.0.0"
-  },
-  "devDependencies": {
-    "rollup": "^2.60.2",
-    "rollup-plugin-typescript2": "^0.31.1",
-    "typescript": "^4.5.2"
-  }
-}
+{
+  "name": "@plohoj/html-editor",
+  "version": "0.1.0",
+  "description": "html-editor it's a tool for helping modification html elements",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plohoj/html-editor.git"
+  },
+  "scripts": {
+    "build": "rollup --config"
+  },
+  "author": "Plokhikh Alexandr",
+  "license": "ISC",
+  "module": "./dist/index.js",
+  "types": "./src/index.ts",
+  "type": "module",
+  "dependencies": {
+    "rxjs": "^7.0.0"
+  },
+  "devDependencies": {
+    "rollup": "^3.9.1",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "typescript": "^4.9.4"
+  }
+}