@progress/kendo-editor-common 1.12.2-develop.5 → 1.12.2-develop.7

package/dist/es2015/lists.js

@@ -1,266 +0,0 @@
-import { Slice, Fragment, NodeRange } from 'prosemirror-model';
-import { TextSelection, NodeSelection } from 'prosemirror-state';
-import { liftTarget, ReplaceAroundStep } from 'prosemirror-transform';
-import { autoJoin } from 'prosemirror-commands';
-import { splitListItem, wrapInList as wrapInList$1 } from 'prosemirror-schema-list';
-import { orderedList, bulletList } from './config/list-settings.js';
-
-const rootListDepth = (pos, nodes) => {
-    // Get the depth of the nearest ancestor list
-    const { bulletList, orderedList, listItem } = nodes;
-    let depth;
-    for (let i = pos.depth - 1; i > 0; i--) {
-        const node = pos.node(i);
-        if (node.type === bulletList || node.type === orderedList) {
-            depth = i;
-        }
-        if (node.type !== bulletList && node.type !== orderedList && node.type !== listItem) {
-            break;
-        }
-    }
-    return depth;
-};
-const getListLiftTarget = (schema, resPos, options) => {
-    // This will return (depth - 1) for root list parent of a list.
-    let target = resPos.depth;
-    const bulletList = schema.nodes[options.bulletList];
-    const orderedList = schema.nodes[options.orderedList];
-    const listItem = schema.nodes[options.listItem];
-    for (let i = resPos.depth; i > 0; i--) {
-        const node = resPos.node(i);
-        if (node.type === bulletList || node.type === orderedList) {
-            target = i;
-        }
-        if (node.type !== bulletList && node.type !== orderedList && node.type !== listItem) {
-            break;
-        }
-    }
-    return target - 1;
-};
-function liftSelectionList(state, tr, options) {
-    // The function will list paragraphs in selection out to level 1 below root list.
-    const { from, to } = state.selection;
-    const { paragraph, heading } = state.schema.nodes;
-    const listCol = [];
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.type === paragraph || node.type === heading) {
-            listCol.push({ node, pos });
-        }
-    });
-    for (let i = listCol.length - 1; i >= 0; i--) {
-        const block = listCol[i];
-        const start = tr.doc.resolve(tr.mapping.map(block.pos));
-        if (start.depth > 0) {
-            let end;
-            if (block.node.textContent && block.node.textContent.length > 0) {
-                end = tr.doc.resolve(tr.mapping.map(block.pos + block.node.textContent.length));
-            }
-            else {
-                end = tr.doc.resolve(tr.mapping.map(block.pos + 1));
-            }
-            const range = start.blockRange(end);
-            if (range) {
-                tr.lift(range, getListLiftTarget(state.schema, start, options));
-            }
-        }
-    }
-    return tr;
-}
-function toggleListCommand(options) {
-    return function (state, dispatch, view) {
-        if (!view) {
-            return false;
-        }
-        state = view.state;
-        const listNode = state.schema.nodes[options.listType];
-        const { $from, $to } = state.selection;
-        const parent = $from.node(-2);
-        const grandgrandParent = $from.node(-3);
-        const isRangeOfSingleType = isRangeOfType(state.doc, $from, $to, listNode);
-        if (((parent && parent.type === listNode) ||
-            (grandgrandParent && grandgrandParent.type === listNode)) &&
-            isRangeOfSingleType) {
-            // Untoggles list
-            return liftListItems(options)(state, dispatch);
-        }
-        else {
-            // Wraps selection in list and converts list type e.g. bullet_list -> ordered_list if needed
-            if (!isRangeOfSingleType) {
-                liftListItems(options)(state, dispatch);
-                state = view.state;
-            }
-            return wrapInList(listNode, options.listAttrs)(state, dispatch);
-        }
-    };
-}
-function liftListItem(state, selection, tr, nodeType) {
-    const listItemNodeType = nodeType || state.schema.nodes.listItem;
-    const { $from, $to } = selection;
-    let range = $from.blockRange($to, node => node.childCount && node.firstChild.type === listItemNodeType);
-    if (!range || range.depth < 2 || $from.node(range.depth - 1).type !== listItemNodeType) {
-        return tr;
-    }
-    const end = range.end;
-    const endOfList = $to.end(range.depth);
-    if (end < endOfList) {
-        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(listItemNodeType.create(undefined, range.parent.copy())), 1, 0), 1, true));
-        range = new NodeRange(tr.doc.resolve($from.pos), tr.doc.resolve(endOfList), range.depth);
-    }
-    return tr.lift(range, liftTarget(range)).scrollIntoView();
-}
-function liftFollowingList(state, from, to, rootListDepthNum, tr, listItem) {
-    // Function will lift list item following selection to level-1.
-    if (!listItem) {
-        listItem = state.schema.nodes.listItem;
-    }
-    let lifted = false;
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (!lifted && node.type === listItem && pos > from) {
-            lifted = true;
-            let listDepth = rootListDepthNum + 3;
-            while (listDepth > rootListDepthNum + 2) {
-                const start = tr.doc.resolve(tr.mapping.map(pos));
-                listDepth = start.depth;
-                const end = tr.doc.resolve(tr.mapping.map(pos + node.textContent.length));
-                const sel = new TextSelection(start, end);
-                tr = liftListItem(state, sel, tr, listItem);
-            }
-        }
-    });
-    return tr;
-}
-function isRangeOfType(doc, $from, $to, nodeType) {
-    // Step through block-nodes between $from and $to and returns false if a node is
-    // found that isn't of the specified type
-    return getAncestorNodesBetween(doc, $from, $to).filter((node) => node.type !== nodeType).length === 0;
-}
-function getAncestorNodesBetween(doc, $from, $to) {
-    // Returns all top-level ancestor-nodes between $from and $to
-    const nodes = [];
-    const maxDepth = findAncestorPosition(doc, $from).depth;
-    let current = doc.resolve($from.start(maxDepth));
-    while (current.pos <= $to.start($to.depth)) {
-        const depth = Math.min(current.depth, maxDepth);
-        const node = current.node(depth);
-        if (node) {
-            nodes.push(node);
-        }
-        if (depth === 0) {
-            break;
-        }
-        let next = doc.resolve(current.after(depth));
-        if (next.start(depth) >= doc.nodeSize - 2) {
-            break;
-        }
-        if (next.depth !== current.depth) {
-            next = doc.resolve(next.pos + 2);
-        }
-        if (next.depth) {
-            current = doc.resolve(next.start(next.depth));
-        }
-        else {
-            current = doc.resolve(next.end(next.depth));
-        }
-    }
-    return nodes;
-}
-function findAncestorPosition(doc, pos) {
-    // Traverse the document until an "ancestor" is found. Any nestable block can be an ancestor.
-    const nestableBlocks = ['blockquote', 'bulletList', 'orderedList'];
-    if (pos.depth === 1) {
-        return pos;
-    }
-    let node = pos.node(pos.depth);
-    let newPos = pos;
-    while (pos.depth >= 1) {
-        pos = doc.resolve(pos.before(pos.depth));
-        node = pos.node(pos.depth);
-        if (node && nestableBlocks.indexOf(node.type.name) !== -1) {
-            newPos = pos;
-        }
-    }
-    return newPos;
-}
-function liftListItems(options) {
-    return function (state, dispatch) {
-        const { tr } = state;
-        const { $from, $to } = state.selection;
-        tr.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
-            // Following condition will ensure that block types `paragraph`, `heading`, `codeBlock`, `blockquote`, `div` are lifted.
-            // isTextblock is true for paragraph, heading, codeBlock.
-            if (node.isTextblock || node.type.name === 'blockquote' || node.type.name === 'div') {
-                const sel = new NodeSelection(tr.doc.resolve(tr.mapping.map(pos)));
-                const range = sel.$from.blockRange(sel.$to);
-                if (!range || sel.$from.parent.type !== state.schema.nodes[options.listItem]) {
-                    return;
-                }
-                const target = range && liftTarget(range);
-                if (target === undefined || target === null) {
-                    return false;
-                }
-                tr.lift(range, target);
-            }
-        });
-        if (dispatch) {
-            dispatch(tr);
-        }
-        return true;
-    };
-}
-function wrapInList(nodeType, attrs = {}) {
-    return autoJoin(wrapInList$1(nodeType, attrs), (before, after) => before.type === after.type && before.type === nodeType);
-}
-const reListStyle = /list\-style\-type:\s?([\w-]+)/;
-/**
- * Extracts list-style-type style from node's attributes.
- *
- * @param attrs - The attributes of the list node
- * @returns The extracted list-style-type.
- */
-const listStyle = (attrs) => {
-    const styleAttr = attrs.style || '';
-    const execArray = reListStyle.exec(styleAttr);
-    return (execArray && execArray[1]) || '';
-};
-const toggleList = (state, dispatch, view, options, command) => {
-    const { listType, listAttrs = { style: null } } = options;
-    const { selection } = state;
-    const fromNode = selection.$from.node(selection.$from.depth - 2);
-    const endNode = selection.$to.node(selection.$to.depth - 2);
-    if (!fromNode || fromNode.type.name !== listType || listStyle(fromNode.attrs) !== listStyle(listAttrs) ||
-        (!endNode || endNode.type.name !== listType || listStyle(endNode.attrs) !== listStyle(listAttrs))) {
-        return toggleListCommand(options)(state, dispatch, view);
-    }
-    else {
-        const nodes = view.state.schema.nodes;
-        const listNodes = {
-            bulletList: nodes[options.bulletList],
-            orderedList: nodes[options.orderedList],
-            listItem: nodes[options.listItem]
-        };
-        const depth = rootListDepth(selection.$to, listNodes);
-        let tr = liftFollowingList(state, selection.$to.pos, selection.$to.end(depth), depth, view.state.tr, listNodes.listItem);
-        tr = liftSelectionList(state, tr, options);
-        tr.setMeta('commandName', command);
-        dispatch(tr);
-        return true;
-    }
-};
-function toggleUnorderedList(state, dispatch, view) {
-    return toggleList(state, dispatch, view, Object.assign({ listType: bulletList.listType }, bulletList.types));
-}
-function toggleOrderedList(state, dispatch, view) {
-    return toggleList(state, dispatch, view, Object.assign({ listType: orderedList.listType }, orderedList.types));
-}
-const splitListItemKeepMarks = (itemType) => (state, dispatch) => {
-    // see https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L321-L327
-    return splitListItem(itemType)(state, tr => {
-        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
-        if (marks) {
-            tr.ensureMarks(marks);
-        }
-        dispatch(tr);
-    });
-};
-
-export { listStyle, splitListItemKeepMarks, toggleList, toggleOrderedList, toggleUnorderedList };

package/dist/es2015/main.js

@@ -1,44 +0,0 @@
-export { domToPmDoc, fragmentToHtml, getHtml, hasSameMarkup, htmlToFragment, parseContent, pmDocToFragment, removeComments, setHtml, trimWhitespace } from './source.js';
-export { flattenNestedSpans } from './flatten-spans.js';
-export { applyInlineStyle, getInlineStyles, toggleInlineFormat } from './inline-style.js';
-export { applyLink, removeLink } from './link.js';
-export { insertText } from './text.js';
-export { insertImage } from './image.js';
-export { alignBlocks, isAligned } from './align.js';
-export { cleanFormatting } from './cleanFormatting.js';
-export { activeNode, blockNodes, changeTextBlock, cleanTextBlockFormatting, formatBlockElements, getBlockFormats, hasNode, parentBlockFormat } from './blockNode.js';
-export { cleanMarks, getActiveMarks, getMark, hasMark, removeAllMarks, selectionMarks } from './mark.js';
-export { canBeIndented, canIndentAsListItem, canOutdentAsListItem, indent, indentBlocks, isIndented, outdent } from './indent.js';
-export { listStyle, toggleList, toggleOrderedList, toggleUnorderedList } from './lists.js';
-export { blockquote, liftBlockquote } from './blockquote.js';
-export { canInsert, expandSelection, expandToWordWrap, getNodeFromSelection, getSelectionText, indentHtml, insertNode, parentNode, selectedLineTextOnly } from './utils.js';
-export { alignCenterRules, alignJustifyRules, alignLeftRules, alignRemoveRules, alignRightRules } from './config/align-rules.js';
-export { indentRules, outdentRules } from './config/indent-rules.js';
-export { marks, nodes } from './config/schema.js';
-export { buildKeymap, buildListKeymap } from './config/keymap.js';
-export { bold, italic, link, strikethrough, subscript, superscript, underline } from './config/commands.js';
-export { pasteCleanup, removeAttribute, removeTag, replaceImageSourcesFromRtf, sanitize, sanitizeClassAttr, sanitizeStyleAttr } from './paste.js';
-export { convertMsLists } from './listConvert.js';
-export { find, findAll, findAt, replace, replaceAll } from './find-replace.js';
-export { placeholder } from './plugins/placeholder.js';
-export { spacesFix } from './plugins/spaces-fix.js';
-export { cspFix } from './plugins/csp-fix.js';
-export { textHighlight, textHighlightKey } from './plugins/highlight.js';
-export { imageResizeKey, imageResizing } from './plugins/image-resize.js';
-export { caretColor, caretColorKey } from './plugins/caret-color.js';
-export { tableResizing } from './plugins/table-resize/index.js';
-export { listMarkersStyles } from './plugins/list-markers-styles.js';
-export * from 'prosemirror-commands';
-export * from 'prosemirror-dropcursor';
-export * from 'prosemirror-gapcursor';
-export * from 'prosemirror-history';
-export * from 'prosemirror-inputrules';
-export * from 'prosemirror-keymap';
-export * from 'prosemirror-model';
-export * from 'prosemirror-schema-list';
-export * from 'prosemirror-state';
-export { CellSelection, TableMap, addColSpan, addColumn, addRow, cellAround, colCount, columnIsHeader, columnResizing, columnResizingPluginKey, deleteRow, deleteTable, findCell, fixTables, fixTablesKey, goToNextCell, inSameTable, isInTable, mergeCells, moveCellForward, nextCell, addColumnAfter as pmAddColumnAfter, addColumnBefore as pmAddColumnBefore, addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore, deleteColumn as pmDeleteColumn, removeColSpan, rowIsHeader, selectedRect, selectionCell, setCellAttr, splitCell, splitCellWithType, tableEditing, tableEditingKey, tableNodeTypes, tableNodes, toggleHeader, toggleHeaderCell, toggleHeaderColumn, toggleHeaderRow, updateColumnsOnResize } from 'prosemirror-tables';
-export * from 'prosemirror-transform';
-export * from 'prosemirror-view';
-export { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, createTable, deleteColumn } from './table.js';
-export { tableColumnResizeKey, tableResizeKey, tableRowResizeKey } from './plugins/table-resize/utils.js';

package/dist/es2015/mark.js

@@ -1,239 +0,0 @@
-import { RemoveMarkStep } from 'prosemirror-transform';
-import { MarkType } from 'prosemirror-model';
-import { parseStyle } from './utils.js';
-
-const markApplies = (doc, ranges, type) => {
-    const loop = i => {
-        const ref = ranges[i];
-        const $from = ref.$from;
-        const $to = ref.$to;
-        let can = $from.depth === 0 ? doc.type.allowsMarkType(type) : false;
-        doc.nodesBetween($from.pos, $to.pos, node => {
-            if (can) {
-                return false;
-            }
-            can = node.inlineContent && node.type.allowsMarkType(type);
-        });
-        if (can) {
-            return { v: true };
-        }
-    };
-    for (let i = 0; i < ranges.length; i++) {
-        const returned = loop(i);
-        if (returned) {
-            return returned.v;
-        }
-    }
-    return false;
-};
-const toggleMark = (markType, attrs, tr) => (state, dispatch) => {
-    const { empty, $cursor, ranges } = state.selection;
-    if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType)) {
-        return false;
-    }
-    if (dispatch) {
-        if ($cursor) {
-            if (markType.isInSet(state.storedMarks || $cursor.marks())) {
-                dispatch(tr.removeStoredMark(markType));
-            }
-            else {
-                dispatch(tr.addStoredMark(markType.create(attrs)));
-            }
-        }
-        else {
-            let has = false;
-            for (let i = 0; !has && i < ranges.length; i++) {
-                const { $from, $to } = ranges[i];
-                has = state.doc.rangeHasMark($from.pos, $to.pos, markType);
-            }
-            for (let i = 0; i < ranges.length; i++) {
-                const { $from, $to } = ranges[i];
-                if (has) {
-                    tr.removeMark($from.pos, $to.pos, markType);
-                }
-                else {
-                    tr.addMark($from.pos, $to.pos, markType.create(attrs));
-                }
-            }
-            dispatch(tr.scrollIntoView());
-        }
-    }
-    return true;
-};
-const removeMark = (tr, from, to, mark) => {
-    if (mark === void 0) {
-        mark = null;
-    }
-    let matched = [], step = 0;
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isInline) {
-            return;
-        }
-        step++;
-        let toRemove = null;
-        if (mark instanceof MarkType) {
-            const found = mark.isInSet(node.marks);
-            if (found) {
-                toRemove = [found];
-            }
-        }
-        else if (mark) {
-            if (mark.isInSet(node.marks)) {
-                toRemove = [mark];
-            }
-        }
-        else {
-            toRemove = node.marks;
-        }
-        if (toRemove && toRemove.length) {
-            const end = Math.min(pos + node.nodeSize, to);
-            for (let i = 0; i < toRemove.length; i++) {
-                let style = toRemove[i], found$1 = (void 0);
-                for (let j = 0; j < matched.length; j++) {
-                    const m = matched[j];
-                    if (m.step === step - 1 && style.eq(m.style)) {
-                        found$1 = m;
-                    }
-                }
-                if (found$1) {
-                    found$1.to = end;
-                    found$1.step = step;
-                }
-                else {
-                    matched.push({ style: style, from: Math.max(pos, from), to: end, step: step });
-                }
-            }
-        }
-    });
-    matched.forEach((m) => { return tr.step(new RemoveMarkStep(m.from, m.to, m.style)); });
-    return tr;
-};
-const removeMarks = (marks, state, dispatch, tr) => {
-    const { $cursor, ranges } = state.selection;
-    tr = tr || state.tr;
-    if ($cursor) {
-        marks.forEach(m => {
-            if (m.isInSet(state.storedMarks || $cursor.marks())) {
-                dispatch(tr.removeStoredMark(m));
-            }
-        });
-    }
-    else {
-        for (let i = 0; i < ranges.length; i++) {
-            const { $from, $to } = ranges[i];
-            marks.forEach(m => {
-                removeMark(tr, $from.pos, $to.pos, m);
-            });
-        }
-        dispatch(tr.scrollIntoView());
-    }
-    return true;
-};
-const toArray = (x) => x instanceof Array ? x : [x];
-const removeAllMarks = ({ except = [] } = {}) => (state, dispatch) => {
-    const tr = state.tr;
-    cleanMarks(tr, { except: toArray(except) });
-    if (tr.docChanged) {
-        dispatch(tr);
-    }
-};
-/**
- * Removes the marks from the selection base on the passed parameter.
- * Requires to dispatch the transaction.
- *
- * @example
- * See `removeAllMarks` or `cleanFormatting` function.
- */
-const cleanMarks = (tr, { except }) => {
-    const { doc, selection } = tr;
-    const schema = doc.type.schema;
-    const { empty, ranges } = selection;
-    const excludedMarkTypes = (except || []).map(mt => mt.name);
-    if (!empty) {
-        const marks = Object.keys(schema.marks)
-            .map(m => schema.marks[m])
-            .filter(mt => excludedMarkTypes.indexOf(mt.name) === -1);
-        ranges.forEach(({ $from, $to }) => {
-            marks.forEach(mark => tr.removeMark($from.pos, $to.pos, mark));
-        });
-    }
-};
-/**
- * Checks if a mark exists in the selection.
- * Used for checking the state of bold, italic, ... and unlink tools.
- */
-const hasMark = (state, options) => {
-    const marks = state.schema.marks;
-    const altMarks = (options.altMarks || []).filter(m => marks[m]);
-    const altStyle = options.altStyle;
-    const { from, $from, to, empty } = state.selection;
-    const type = marks[options.mark];
-    const doc = state.doc;
-    let result = false;
-    let currMarks;
-    if (empty) {
-        currMarks = state.storedMarks || $from.marks();
-        result = (type && type.isInSet(currMarks)) || altMarks.some(m => marks[m].isInSet(currMarks));
-    }
-    else {
-        result = (type && doc.rangeHasMark(from, to, type)) || altMarks.some(m => doc.rangeHasMark(from, to, marks[m]));
-    }
-    if (!result && altStyle && marks.style) {
-        return selectionMarks(state, marks.style)
-            .some(mark => styleValue(mark, altStyle) !== null);
-    }
-    return Boolean(result);
-};
-const styleValue = (mark, style) => {
-    const styleText = (mark && mark.attrs.style) || '';
-    const styles = parseStyle(styleText);
-    const styleNames = Object.keys(styles);
-    for (let i = 0; i < styleNames.length; i++) {
-        const name = styleNames[i];
-        if (name.toLowerCase() === style.name && style.value.test(styles[name])) {
-            return styles[name];
-        }
-    }
-    return null;
-};
-/**
- * Returns the marks of a specific type for every inline node in the selection.
- */
-const selectionMarks = (state, markType) => {
-    const { from, $from, to, empty } = state.selection;
-    const marks = [];
-    if (empty) {
-        marks.push(markType.isInSet(state.storedMarks || $from.marks()));
-    }
-    else {
-        state.doc.nodesBetween(from, to, node => {
-            if (node.isInline) {
-                marks.push(markType.isInSet(node.marks));
-            }
-        });
-    }
-    return marks;
-};
-/**
- * Returns the specified mark which wraps the selection.
- * Used by link tools.
- */
-const getMark = (state, markType) => {
-    const marks = selectionMarks(state, markType);
-    const filtered = marks.filter(m => Boolean(m));
-    return marks.length === filtered.length ? marks[0] : undefined;
-};
-/**
- * **Deprecated.** Use `selectionMarks` function instead.
- */
-const getActiveMarks = (state, markType) => {
-    const marks = selectionMarks(state, markType);
-    const filtered = marks.filter(m => Boolean(m));
-    const hasNodesWithoutMarks = marks.length !== filtered.length;
-    return {
-        hasNodesWithoutMarks,
-        marks: filtered
-    };
-};
-
-export { cleanMarks, getActiveMarks, getMark, hasMark, markApplies, removeAllMarks, removeMark, removeMarks, selectionMarks, styleValue, toggleMark };

package/dist/es2015/node_modules/tslib/tslib.es6.js

@@ -1,35 +0,0 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-export { __rest };