From 2ee25bcb500c2e1a001fdf39389cc4005873b86b Mon Sep 17 00:00:00 2001 From: fantasticit Date: Fri, 20 May 2022 17:54:12 +0800 Subject: [PATCH] chore: add npmrc --- .gitignore | 1 - .npmrc | 1 + .../src/tiptap/core/y-prosemirror/lib.js | 318 ++++ .../y-prosemirror/plugins/cursor-plugin.js | 184 +++ .../tiptap/core/y-prosemirror/plugins/keys.js | 22 + .../core/y-prosemirror/plugins/sync-plugin.js | 921 ++++++++++++ .../core/y-prosemirror/plugins/undo-plugin.js | 100 ++ .../core/y-prosemirror/y-prosemirror.js | 13 + .../collaboration/collaboration/index.tsx | 2 +- pnpm-lock.yaml | 1326 ++++++----------- 10 files changed, 2048 insertions(+), 840 deletions(-) create mode 100644 .npmrc create mode 100644 packages/client/src/tiptap/core/y-prosemirror/lib.js create mode 100644 packages/client/src/tiptap/core/y-prosemirror/plugins/cursor-plugin.js create mode 100644 packages/client/src/tiptap/core/y-prosemirror/plugins/keys.js create mode 100644 packages/client/src/tiptap/core/y-prosemirror/plugins/sync-plugin.js create mode 100644 packages/client/src/tiptap/core/y-prosemirror/plugins/undo-plugin.js create mode 100644 packages/client/src/tiptap/core/y-prosemirror/y-prosemirror.js diff --git a/.gitignore b/.gitignore index a1817493..98dac098 100644 --- a/.gitignore +++ b/.gitignore @@ -7,7 +7,6 @@ dist-ssr coverage test-results .pnpm-store -.npmrc tsconfig.tsbuildinfo .env diff --git a/.npmrc b/.npmrc new file mode 100644 index 00000000..fa4e0952 --- /dev/null +++ b/.npmrc @@ -0,0 +1 @@ +strict-peer-dependencies=false \ No newline at end of file diff --git a/packages/client/src/tiptap/core/y-prosemirror/lib.js b/packages/client/src/tiptap/core/y-prosemirror/lib.js new file mode 100644 index 00000000..28a3a156 --- /dev/null +++ b/packages/client/src/tiptap/core/y-prosemirror/lib.js @@ -0,0 +1,318 @@ +import { updateYFragment } from './plugins/sync-plugin.js'; // eslint-disable-line +import * as Y from 'yjs'; +import { EditorView } from 'prosemirror-view'; // eslint-disable-line +import { Node, Schema } from 'prosemirror-model'; // eslint-disable-line +import * as error from 'lib0/error'; +import * as map from 'lib0/map'; +import * as eventloop from 'lib0/eventloop'; + +/** + * Either a node if type is YXmlElement or an Array of text nodes if YXmlText + * @typedef {Map>} ProsemirrorMapping + */ + +/** + * Is null if no timeout is in progress. + * Is defined if a timeout is in progress. + * Maps from view + * @type {Map>|null} + */ +let viewsToUpdate = null; + +const updateMetas = () => { + const ups = /** @type {Map>} */ (viewsToUpdate); + viewsToUpdate = null; + ups.forEach((metas, view) => { + const tr = view.state.tr; + metas.forEach((val, key) => { + tr.setMeta(key, val); + }); + view.dispatch(tr); + }); +}; + +export const setMeta = (view, key, value) => { + if (!viewsToUpdate) { + viewsToUpdate = new Map(); + eventloop.timeout(0, updateMetas); + } + map.setIfUndefined(viewsToUpdate, view, map.create).set(key, value); +}; + +/** + * Transforms a Prosemirror based absolute position to a Yjs Cursor (relative position in the Yjs model). + * + * @param {number} pos + * @param {Y.XmlFragment} type + * @param {ProsemirrorMapping} mapping + * @return {any} relative position + */ +export const absolutePositionToRelativePosition = (pos, type, mapping) => { + if (pos === 0) { + return Y.createRelativePositionFromTypeIndex(type, 0); + } + /** + * @type {any} + */ + let n = type._first === null ? null : /** @type {Y.ContentType} */ (type._first.content).type; + while (n !== null && type !== n) { + if (n instanceof Y.XmlText) { + if (n._length >= pos) { + return Y.createRelativePositionFromTypeIndex(n, pos); + } else { + pos -= n._length; + } + if (n._item !== null && n._item.next !== null) { + n = /** @type {Y.ContentType} */ (n._item.next.content).type; + } else { + do { + n = n._item === null ? null : n._item.parent; + pos--; + } while (n !== type && n !== null && n._item !== null && n._item.next === null); + if (n !== null && n !== type) { + // @ts-gnore we know that n.next !== null because of above loop conditition + n = n._item === null ? null : /** @type {Y.ContentType} */ (/** @type Y.Item */ (n._item.next).content).type; + } + } + } else { + const pNodeSize = /** @type {any} */ (mapping.get(n) || { nodeSize: 0 }).nodeSize; + if (n._first !== null && pos < pNodeSize) { + n = /** @type {Y.ContentType} */ (n._first.content).type; + pos--; + } else { + if (pos === 1 && n._length === 0 && pNodeSize > 1) { + // edge case, should end in this paragraph + return new Y.RelativePosition( + n._item === null ? null : n._item.id, + n._item === null ? Y.findRootTypeKey(n) : null, + null + ); + } + pos -= pNodeSize; + if (n._item !== null && n._item.next !== null) { + n = /** @type {Y.ContentType} */ (n._item.next.content).type; + } else { + if (pos === 0) { + // set to end of n.parent + n = n._item === null ? n : n._item.parent; + return new Y.RelativePosition( + n._item === null ? null : n._item.id, + n._item === null ? Y.findRootTypeKey(n) : null, + null + ); + } + do { + n = /** @type {Y.Item} */ (n._item).parent; + pos--; + } while (n !== type && /** @type {Y.Item} */ (n._item).next === null); + // if n is null at this point, we have an unexpected case + if (n !== type) { + // We know that n._item.next is defined because of above loop condition + n = /** @type {Y.ContentType} */ (/** @type {Y.Item} */ (/** @type {Y.Item} */ (n._item).next).content) + .type; + } + } + } + } + if (n === null) { + throw error.unexpectedCase(); + } + if (pos === 0 && n.constructor !== Y.XmlText && n !== type) { + // TODO: set to <= 0 + return createRelativePosition(n._item.parent, n._item); + } + } + return Y.createRelativePositionFromTypeIndex(type, type._length); +}; + +const createRelativePosition = (type, item) => { + let typeid = null; + let tname = null; + if (type._item === null) { + tname = Y.findRootTypeKey(type); + } else { + typeid = Y.createID(type._item.id.client, type._item.id.clock); + } + return new Y.RelativePosition(typeid, tname, item.id); +}; + +/** + * @param {Y.Doc} y + * @param {Y.XmlFragment} documentType Top level type that is bound to pView + * @param {any} relPos Encoded Yjs based relative position + * @param {ProsemirrorMapping} mapping + * @return {null|number} + */ +export const relativePositionToAbsolutePosition = (y, documentType, relPos, mapping) => { + const decodedPos = Y.createAbsolutePositionFromRelativePosition(relPos, y); + if (decodedPos === null || (decodedPos.type !== documentType && !Y.isParentOf(documentType, decodedPos.type._item))) { + return null; + } + let type = decodedPos.type; + let pos = 0; + if (type.constructor === Y.XmlText) { + pos = decodedPos.index; + } else if (type._item === null || !type._item.deleted) { + let n = type._first; + let i = 0; + while (i < type._length && i < decodedPos.index && n !== null) { + if (!n.deleted) { + const t = /** @type {Y.ContentType} */ (n.content).type; + i++; + if (t instanceof Y.XmlText) { + pos += t._length; + } else { + pos += /** @type {any} */ (mapping.get(t)).nodeSize; + } + } + n = /** @type {Y.Item} */ (n.right); + } + pos += 1; // increase because we go out of n + } + while (type !== documentType && type._item !== null) { + // @ts-ignore + const parent = type._item.parent; + // @ts-ignore + if (parent._item === null || !parent._item.deleted) { + pos += 1; // the start tag + let n = /** @type {Y.AbstractType} */ (parent)._first; + // now iterate until we found type + while (n !== null) { + const contentType = /** @type {Y.ContentType} */ (n.content).type; + if (contentType === type) { + break; + } + if (!n.deleted) { + if (contentType instanceof Y.XmlText) { + pos += contentType._length; + } else { + pos += /** @type {any} */ (mapping.get(contentType)).nodeSize; + } + } + n = n.right; + } + } + type = /** @type {Y.AbstractType} */ (parent); + } + return pos - 1; // we don't count the most outer tag, because it is a fragment +}; + +/** + * Utility method to convert a Prosemirror Doc Node into a Y.Doc. + * + * This can be used when importing existing content to Y.Doc for the first time, + * note that this should not be used to rehydrate a Y.Doc from a database once + * collaboration has begun as all history will be lost + * + * @param {Node} doc + * @param {string} xmlFragment + * @return {Y.Doc} + */ +export function prosemirrorToYDoc(doc, xmlFragment = 'prosemirror') { + const ydoc = new Y.Doc(); + const type = /** @type {Y.XmlFragment} */ (ydoc.get(xmlFragment, Y.XmlFragment)); + if (!type.doc) { + return ydoc; + } + + updateYFragment(type.doc, type, doc, new Map()); + return type.doc; +} + +/** + * Utility method to convert Prosemirror compatible JSON into a Y.Doc. + * + * This can be used when importing existing content to Y.Doc for the first time, + * note that this should not be used to rehydrate a Y.Doc from a database once + * collaboration has begun as all history will be lost + * + * @param {Schema} schema + * @param {any} state + * @param {string} xmlFragment + * @return {Y.Doc} + */ +export function prosemirrorJSONToYDoc(schema, state, xmlFragment = 'prosemirror') { + const doc = Node.fromJSON(schema, state); + return prosemirrorToYDoc(doc, xmlFragment); +} + +/** + * Utility method to convert a Y.Doc to a Prosemirror Doc node. + * + * @param {Schema} schema + * @param {Y.Doc} ydoc + * @return {Node} + */ +export function yDocToProsemirror(schema, ydoc) { + const state = yDocToProsemirrorJSON(ydoc); + return Node.fromJSON(schema, state); +} + +/** + * Utility method to convert a Y.Doc to Prosemirror compatible JSON. + * + * @param {Y.Doc} ydoc + * @param {string} xmlFragment + * @return {Record} + */ +export function yDocToProsemirrorJSON(ydoc, xmlFragment = 'prosemirror') { + const items = ydoc.getXmlFragment(xmlFragment).toArray(); + + function serialize(item) { + /** + * @type {Object} NodeObject + * @property {string} NodeObject.type + * @property {Record=} NodeObject.attrs + * @property {Array=} NodeObject.content + */ + let response; + + // TODO: Must be a better way to detect text nodes than this + if (!item.nodeName) { + const delta = item.toDelta(); + response = delta.map((d) => { + const text = { + type: 'text', + text: d.insert, + }; + + if (d.attributes) { + text.marks = Object.keys(d.attributes).map((type) => { + const attrs = d.attributes[type]; + const mark = { + type, + }; + + if (Object.keys(attrs)) { + mark.attrs = attrs; + } + + return mark; + }); + } + return text; + }); + } else { + response = { + type: item.nodeName, + }; + + const attrs = item.getAttributes(); + if (Object.keys(attrs).length) { + response.attrs = attrs; + } + + const children = item.toArray(); + if (children.length) { + response.content = children.map(serialize).flat(); + } + } + + return response; + } + + return { + type: 'doc', + content: items.map(serialize), + }; +} diff --git a/packages/client/src/tiptap/core/y-prosemirror/plugins/cursor-plugin.js b/packages/client/src/tiptap/core/y-prosemirror/plugins/cursor-plugin.js new file mode 100644 index 00000000..b90e6e24 --- /dev/null +++ b/packages/client/src/tiptap/core/y-prosemirror/plugins/cursor-plugin.js @@ -0,0 +1,184 @@ +import * as math from 'lib0/math'; +import { Plugin } from 'prosemirror-state'; // eslint-disable-line +import { Decoration, DecorationSet } from 'prosemirror-view'; // eslint-disable-line +import { Awareness } from 'y-protocols/awareness'; // eslint-disable-line +import * as Y from 'yjs'; + +import { absolutePositionToRelativePosition, relativePositionToAbsolutePosition, setMeta } from '../lib.js'; +import { yCursorPluginKey, ySyncPluginKey } from './keys.js'; + +/** + * Default generator for a cursor element + * + * @param {any} user user data + * @return HTMLElement + */ +export const defaultCursorBuilder = (user) => { + const cursor = document.createElement('span'); + cursor.classList.add('ProseMirror-yjs-cursor'); + cursor.setAttribute('style', `border-color: ${user.color}`); + const userDiv = document.createElement('div'); + userDiv.setAttribute('style', `background-color: ${user.color}`); + userDiv.insertBefore(document.createTextNode(user.name), null); + cursor.insertBefore(userDiv, null); + return cursor; +}; + +const rxValidColor = /^#[0-9a-fA-F]{6}$/; + +/** + * @param {any} state + * @param {Awareness} awareness + * @return {any} DecorationSet + */ +export const createDecorations = (state, awareness, createCursor) => { + const ystate = ySyncPluginKey.getState(state); + const y = ystate.doc; + const decorations = []; + if (ystate.snapshot != null || ystate.prevSnapshot != null || ystate.binding === null) { + // do not render cursors while snapshot is active + return DecorationSet.create(state.doc, []); + } + awareness.getStates().forEach((aw, clientId) => { + if (clientId === y.clientID) { + return; + } + if (aw.cursor != null) { + const user = aw.user || {}; + if (user.color == null) { + user.color = '#ffa500'; + } else if (!rxValidColor.test(user.color)) { + // We only support 6-digit RGB colors in y-prosemirror + console.warn('A user uses an unsupported color format', user); + } + if (user.name == null) { + user.name = `User: ${clientId}`; + } + let anchor = relativePositionToAbsolutePosition( + y, + ystate.type, + Y.createRelativePositionFromJSON(aw.cursor.anchor), + ystate.binding.mapping + ); + let head = relativePositionToAbsolutePosition( + y, + ystate.type, + Y.createRelativePositionFromJSON(aw.cursor.head), + ystate.binding.mapping + ); + if (anchor !== null && head !== null) { + const maxsize = math.max(state.doc.content.size - 1, 0); + anchor = math.min(anchor, maxsize); + head = math.min(head, maxsize); + decorations.push(Decoration.widget(head, () => createCursor(user), { key: clientId + '', side: 10 })); + const from = math.min(anchor, head); + const to = math.max(anchor, head); + decorations.push( + Decoration.inline( + from, + to, + { style: `background-color: ${user.color}70` }, + { inclusiveEnd: true, inclusiveStart: false } + ) + ); + } + } + }); + return DecorationSet.create(state.doc, decorations); +}; + +/** + * A prosemirror plugin that listens to awareness information on Yjs. + * This requires that a `prosemirrorPlugin` is also bound to the prosemirror. + * + * @public + * @param {Awareness} awareness + * @param {object} [opts] + * @param {function(any):HTMLElement} [opts.cursorBuilder] + * @param {function(any):any} [opts.getSelection] + * @param {string} [opts.cursorStateField] By default all editor bindings use the awareness 'cursor' field to propagate cursor information. + * @return {any} + */ +export const yCursorPlugin = ( + awareness, + { cursorBuilder = defaultCursorBuilder, getSelection = (state) => state.selection } = {}, + cursorStateField = 'cursor' +) => + new Plugin({ + key: yCursorPluginKey, + state: { + init(_, state) { + return createDecorations(state, awareness, cursorBuilder); + }, + apply(tr, prevState, oldState, newState) { + const ystate = ySyncPluginKey.getState(newState); + const yCursorState = tr.getMeta(yCursorPluginKey); + if ((ystate && ystate.isChangeOrigin) || (yCursorState && yCursorState.awarenessUpdated)) { + return createDecorations(newState, awareness, cursorBuilder); + } + return prevState.map(tr.mapping, tr.doc); + }, + }, + props: { + decorations: (state) => { + return yCursorPluginKey.getState(state); + }, + }, + view: (view) => { + const awarenessListener = () => { + // @ts-ignore + if (view.docView) { + setMeta(view, yCursorPluginKey, { awarenessUpdated: true }); + } + }; + const updateCursorInfo = () => { + const ystate = ySyncPluginKey.getState(view.state); + // @note We make implicit checks when checking for the cursor property + const current = awareness.getLocalState() || {}; + if (view.hasFocus() && ystate.binding !== null) { + const selection = getSelection(view.state); + /** + * @type {Y.RelativePosition} + */ + const anchor = absolutePositionToRelativePosition(selection.anchor, ystate.type, ystate.binding.mapping); + /** + * @type {Y.RelativePosition} + */ + const head = absolutePositionToRelativePosition(selection.head, ystate.type, ystate.binding.mapping); + if ( + current.cursor == null || + !Y.compareRelativePositions(Y.createRelativePositionFromJSON(current.cursor.anchor), anchor) || + !Y.compareRelativePositions(Y.createRelativePositionFromJSON(current.cursor.head), head) + ) { + awareness.setLocalStateField(cursorStateField, { + anchor, + head, + }); + } + } else if ( + current.cursor != null && + relativePositionToAbsolutePosition( + ystate.doc, + ystate.type, + Y.createRelativePositionFromJSON(current.cursor.anchor), + ystate.binding.mapping + ) !== null + ) { + // delete cursor information if current cursor information is owned by this editor binding + awareness.setLocalStateField(cursorStateField, null); + } + }; + awareness.on('change', awarenessListener); + view.dom.addEventListener('focusin', updateCursorInfo); + view.dom.addEventListener('focusout', updateCursorInfo); + return { + update: updateCursorInfo, + destroy: () => { + view.dom.removeEventListener('focusin', updateCursorInfo); + view.dom.removeEventListener('focusout', updateCursorInfo); + awareness.off('change', awarenessListener); + awareness.setLocalStateField(cursorStateField, null); + }, + }; + }, + }); diff --git a/packages/client/src/tiptap/core/y-prosemirror/plugins/keys.js b/packages/client/src/tiptap/core/y-prosemirror/plugins/keys.js new file mode 100644 index 00000000..c3932e21 --- /dev/null +++ b/packages/client/src/tiptap/core/y-prosemirror/plugins/keys.js @@ -0,0 +1,22 @@ +import { PluginKey } from 'prosemirror-state'; // eslint-disable-line + +/** + * The unique prosemirror plugin key for syncPlugin + * + * @public + */ +export const ySyncPluginKey = new PluginKey('y-sync'); + +/** + * The unique prosemirror plugin key for undoPlugin + * + * @public + */ +export const yUndoPluginKey = new PluginKey('y-undo'); + +/** + * The unique prosemirror plugin key for cursorPlugin + * + * @public + */ +export const yCursorPluginKey = new PluginKey('yjs-cursor'); diff --git a/packages/client/src/tiptap/core/y-prosemirror/plugins/sync-plugin.js b/packages/client/src/tiptap/core/y-prosemirror/plugins/sync-plugin.js new file mode 100644 index 00000000..358a9807 --- /dev/null +++ b/packages/client/src/tiptap/core/y-prosemirror/plugins/sync-plugin.js @@ -0,0 +1,921 @@ +/** + * @module bindings/prosemirror + */ + +import { simpleDiff } from 'lib0/diff'; +import * as dom from 'lib0/dom'; +import * as environment from 'lib0/environment'; +import * as error from 'lib0/error'; +import * as math from 'lib0/math'; +import { createMutex } from 'lib0/mutex'; +import * as object from 'lib0/object'; +import * as random from 'lib0/random'; +import * as set from 'lib0/set'; +import * as PModel from 'prosemirror-model'; +import { Plugin, TextSelection } from 'prosemirror-state'; // eslint-disable-line +import * as Y from 'yjs'; + +import { absolutePositionToRelativePosition, relativePositionToAbsolutePosition } from '../lib.js'; +import { ySyncPluginKey } from './keys.js'; + +/** + * @param {Y.Item} item + * @param {Y.Snapshot} [snapshot] + */ +export const isVisible = (item, snapshot) => + snapshot === undefined + ? !item.deleted + : snapshot.sv.has(item.id.client) && + /** @type {number} */ (snapshot.sv.get(item.id.client)) > item.id.clock && + !Y.isDeleted(snapshot.ds, item.id); + +/** + * Either a node if type is YXmlElement or an Array of text nodes if YXmlText + * @typedef {Map>} ProsemirrorMapping + */ + +/** + * @typedef {Object} ColorDef + * @property {string} ColorDef.light + * @property {string} ColorDef.dark + */ + +/** + * @typedef {Object} YSyncOpts + * @property {Array} [YSyncOpts.colors] + * @property {Map} [YSyncOpts.colorMapping] + * @property {Y.PermanentUserData|null} [YSyncOpts.permanentUserData] + */ + +/** + * @type {Array} + */ +const defaultColors = [{ light: '#ecd44433', dark: '#ecd444' }]; + +/** + * @param {Map} colorMapping + * @param {Array} colors + * @param {string} user + * @return {ColorDef} + */ +const getUserColor = (colorMapping, colors, user) => { + // @todo do not hit the same color twice if possible + if (!colorMapping.has(user)) { + if (colorMapping.size < colors.length) { + const usedColors = set.create(); + colorMapping.forEach((color) => usedColors.add(color)); + colors = colors.filter((color) => !usedColors.has(color)); + } + colorMapping.set(user, random.oneOf(colors)); + } + return /** @type {ColorDef} */ (colorMapping.get(user)); +}; + +/** + * This plugin listens to changes in prosemirror view and keeps yXmlState and view in sync. + * + * This plugin also keeps references to the type and the shared document so other plugins can access it. + * @param {Y.XmlFragment} yXmlFragment + * @param {YSyncOpts} opts + * @return {any} Returns a prosemirror plugin that binds to this type + */ +export const ySyncPlugin = ( + yXmlFragment, + { colors = defaultColors, colorMapping = new Map(), permanentUserData = null } = {} +) => { + let changedInitialContent = false; + const plugin = new Plugin({ + props: { + editable: (state) => { + const syncState = ySyncPluginKey.getState(state); + return syncState.snapshot == null && syncState.prevSnapshot == null; + }, + }, + key: ySyncPluginKey, + state: { + init: (initargs, state) => { + return { + type: yXmlFragment, + doc: yXmlFragment.doc, + binding: null, + snapshot: null, + prevSnapshot: null, + isChangeOrigin: false, + colors, + colorMapping, + permanentUserData, + }; + }, + apply: (tr, pluginState) => { + const change = tr.getMeta(ySyncPluginKey); + if (change !== undefined) { + pluginState = Object.assign({}, pluginState); + for (const key in change) { + pluginState[key] = change[key]; + } + } + // always set isChangeOrigin. If undefined, this is not change origin. + pluginState.isChangeOrigin = change !== undefined && !!change.isChangeOrigin; + if (pluginState.binding !== null) { + if (change !== undefined && (change.snapshot != null || change.prevSnapshot != null)) { + // snapshot changed, rerender next + setTimeout(() => { + if (change.restore == null) { + pluginState.binding._renderSnapshot(change.snapshot, change.prevSnapshot, pluginState); + } else { + pluginState.binding._renderSnapshot(change.snapshot, change.snapshot, pluginState); + // reset to current prosemirror state + delete pluginState.restore; + delete pluginState.snapshot; + delete pluginState.prevSnapshot; + pluginState.binding._prosemirrorChanged(pluginState.binding.prosemirrorView.state.doc); + } + }, 0); + } + } + return pluginState; + }, + }, + view: (view) => { + const binding = new ProsemirrorBinding(yXmlFragment, view); + // Make sure this is called in a separate context + setTimeout(() => { + binding._forceRerender(); + view.dispatch(view.state.tr.setMeta(ySyncPluginKey, { binding })); + }, 0); + return { + update: () => { + const pluginState = plugin.getState(view.state); + if (pluginState.snapshot == null && pluginState.prevSnapshot == null) { + if ( + changedInitialContent || + view.state.doc.content.findDiffStart(view.state.doc.type.createAndFill().content) !== null + ) { + changedInitialContent = true; + binding._prosemirrorChanged(view.state.doc); + } + } + }, + destroy: () => { + binding.destroy(); + }, + }; + }, + }); + return plugin; +}; + +/** + * @param {any} tr + * @param {any} relSel + * @param {ProsemirrorBinding} binding + */ +const restoreRelativeSelection = (tr, relSel, binding) => { + if (relSel !== null && relSel.anchor !== null && relSel.head !== null) { + const anchor = relativePositionToAbsolutePosition(binding.doc, binding.type, relSel.anchor, binding.mapping); + const head = relativePositionToAbsolutePosition(binding.doc, binding.type, relSel.head, binding.mapping); + if (anchor !== null && head !== null) { + tr = tr.setSelection(TextSelection.create(tr.doc, anchor, head)); + } + } +}; + +export const getRelativeSelection = (pmbinding, state) => ({ + anchor: absolutePositionToRelativePosition(state.selection.anchor, pmbinding.type, pmbinding.mapping), + head: absolutePositionToRelativePosition(state.selection.head, pmbinding.type, pmbinding.mapping), +}); + +/** + * Binding for prosemirror. + * + * @protected + */ +export class ProsemirrorBinding { + /** + * @param {Y.XmlFragment} yXmlFragment The bind source + * @param {any} prosemirrorView The target binding + */ + constructor(yXmlFragment, prosemirrorView) { + this.type = yXmlFragment; + this.prosemirrorView = prosemirrorView; + this.mux = createMutex(); + /** + * @type {ProsemirrorMapping} + */ + this.mapping = new Map(); + this._observeFunction = this._typeChanged.bind(this); + /** + * @type {Y.Doc} + */ + // @ts-ignore + this.doc = yXmlFragment.doc; + /** + * current selection as relative positions in the Yjs model + */ + this.beforeTransactionSelection = null; + this.beforeAllTransactions = () => { + if (this.beforeTransactionSelection === null) { + this.beforeTransactionSelection = getRelativeSelection(this, prosemirrorView.state); + } + }; + this.afterAllTransactions = () => { + this.beforeTransactionSelection = null; + }; + + this.doc.on('beforeAllTransactions', this.beforeAllTransactions); + this.doc.on('afterAllTransactions', this.afterAllTransactions); + yXmlFragment.observeDeep(this._observeFunction); + + this._domSelectionInView = null; + } + + _isLocalCursorInView() { + if (!this.prosemirrorView.hasFocus()) return false; + if (environment.isBrowser && this._domSelectionInView === null) { + // Calculate the domSelectionInView and clear by next tick after all events are finished + setTimeout(() => { + this._domSelectionInView = null; + }, 0); + this._domSelectionInView = this._isDomSelectionInView(); + } + return this._domSelectionInView; + } + + _isDomSelectionInView() { + const selection = this.prosemirrorView._root.getSelection(); + + const range = this.prosemirrorView._root.createRange(); + range.setStart(selection.anchorNode, selection.anchorOffset); + range.setEnd(selection.focusNode, selection.focusOffset); + + // This is a workaround for an edgecase where getBoundingClientRect will + // return zero values if the selection is collapsed at the start of a newline + // see reference here: https://stackoverflow.com/a/59780954 + const rects = range.getClientRects(); + if (rects.length === 0) { + // probably buggy newline behavior, explicitly select the node contents + if (range.startContainer && range.collapsed) { + range.selectNodeContents(range.startContainer); + } + } + + const bounding = range.getBoundingClientRect(); + const documentElement = dom.doc.documentElement; + + return ( + bounding.bottom >= 0 && + bounding.right >= 0 && + bounding.left <= (window.innerWidth || documentElement.clientWidth || 0) && + bounding.top <= (window.innerHeight || documentElement.clientHeight || 0) + ); + } + + renderSnapshot(snapshot, prevSnapshot) { + if (!prevSnapshot) { + prevSnapshot = Y.createSnapshot(Y.createDeleteSet(), new Map()); + } + this.prosemirrorView.dispatch(this.prosemirrorView.state.tr.setMeta(ySyncPluginKey, { snapshot, prevSnapshot })); + } + + unrenderSnapshot() { + this.mapping = new Map(); + this.mux(() => { + const fragmentContent = this.type + .toArray() + .map((t) => + createNodeFromYElement(/** @type {Y.XmlElement} */ (t), this.prosemirrorView.state.schema, this.mapping) + ) + .filter((n) => n !== null); + // @ts-ignore + const tr = this.prosemirrorView.state.tr.replace( + 0, + this.prosemirrorView.state.doc.content.size, + new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0) + ); + tr.setMeta(ySyncPluginKey, { snapshot: null, prevSnapshot: null }); + this.prosemirrorView.dispatch(tr); + }); + } + + _forceRerender() { + this.mapping = new Map(); + this.mux(() => { + const fragmentContent = this.type + .toArray() + .map((t) => + createNodeFromYElement(/** @type {Y.XmlElement} */ (t), this.prosemirrorView.state.schema, this.mapping) + ) + .filter((n) => n !== null); + // @ts-ignore + const tr = this.prosemirrorView.state.tr.replace( + 0, + this.prosemirrorView.state.doc.content.size, + new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0) + ); + this.prosemirrorView.dispatch(tr.setMeta(ySyncPluginKey, { isChangeOrigin: true })); + }); + } + + /** + * @param {Y.Snapshot} snapshot + * @param {Y.Snapshot} prevSnapshot + * @param {Object} pluginState + */ + _renderSnapshot(snapshot, prevSnapshot, pluginState) { + if (!snapshot) { + snapshot = Y.snapshot(this.doc); + } + // clear mapping because we are going to rerender + this.mapping = new Map(); + this.mux(() => { + this.doc.transact((transaction) => { + // before rendering, we are going to sanitize ops and split deleted ops + // if they were deleted by seperate users. + const pud = pluginState.permanentUserData; + if (pud) { + pud.dss.forEach((ds) => { + Y.iterateDeletedStructs(transaction, ds, (item) => {}); + }); + } + const computeYChange = (type, id) => { + const user = type === 'added' ? pud.getUserByClientId(id.client) : pud.getUserByDeletedId(id); + return { + user, + type, + color: getUserColor(pluginState.colorMapping, pluginState.colors, user), + }; + }; + // Create document fragment and render + const fragmentContent = Y.typeListToArraySnapshot(this.type, new Y.Snapshot(prevSnapshot.ds, snapshot.sv)) + .map((t) => { + if (!t._item.deleted || isVisible(t._item, snapshot) || isVisible(t._item, prevSnapshot)) { + return createNodeFromYElement( + t, + this.prosemirrorView.state.schema, + new Map(), + snapshot, + prevSnapshot, + computeYChange + ); + } else { + // No need to render elements that are not visible by either snapshot. + // If a client adds and deletes content in the same snapshot the element is not visible by either snapshot. + return null; + } + }) + .filter((n) => n !== null); + // @ts-ignore + const tr = this.prosemirrorView.state.tr.replace( + 0, + this.prosemirrorView.state.doc.content.size, + new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0) + ); + this.prosemirrorView.dispatch(tr.setMeta(ySyncPluginKey, { isChangeOrigin: true })); + }, ySyncPluginKey); + }); + } + + /** + * @param {Array} events + * @param {Y.Transaction} transaction + */ + _typeChanged(events, transaction) { + const syncState = ySyncPluginKey.getState(this.prosemirrorView.state); + if (events.length === 0 || syncState.snapshot != null || syncState.prevSnapshot != null) { + // drop out if snapshot is active + this.renderSnapshot(syncState.snapshot, syncState.prevSnapshot); + return; + } + this.mux(() => { + /** + * @param {any} _ + * @param {Y.AbstractType} type + */ + const delType = (_, type) => this.mapping.delete(type); + Y.iterateDeletedStructs( + transaction, + transaction.deleteSet, + (struct) => + struct.constructor === Y.Item && + this.mapping.delete(/** @type {Y.ContentType} */ (/** @type {Y.Item} */ (struct).content).type) + ); + transaction.changed.forEach(delType); + transaction.changedParentTypes.forEach(delType); + const fragmentContent = this.type + .toArray() + .map((t) => + createNodeIfNotExists( + /** @type {Y.XmlElement | Y.XmlHook} */ (t), + this.prosemirrorView.state.schema, + this.mapping + ) + ) + .filter((n) => n !== null); + // @ts-ignore + let tr = this.prosemirrorView.state.tr.replace( + 0, + this.prosemirrorView.state.doc.content.size, + new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0) + ); + restoreRelativeSelection(tr, this.beforeTransactionSelection, this); + tr = tr.setMeta(ySyncPluginKey, { isChangeOrigin: true }); + if (this.beforeTransactionSelection !== null && this._isLocalCursorInView()) { + tr.scrollIntoView(); + } + this.prosemirrorView.dispatch(tr); + }); + } + + _prosemirrorChanged(doc) { + this.mux(() => { + this.doc.transact(() => { + updateYFragment(this.doc, this.type, doc, this.mapping); + this.beforeTransactionSelection = getRelativeSelection(this, this.prosemirrorView.state); + }, ySyncPluginKey); + }); + } + + destroy() { + this.type.unobserveDeep(this._observeFunction); + this.doc.off('beforeAllTransactions', this.beforeAllTransactions); + this.doc.off('afterAllTransactions', this.afterAllTransactions); + } +} + +/** + * @private + * @param {Y.XmlElement | Y.XmlHook} el + * @param {PModel.Schema} schema + * @param {ProsemirrorMapping} mapping + * @param {Y.Snapshot} [snapshot] + * @param {Y.Snapshot} [prevSnapshot] + * @param {function('removed' | 'added', Y.ID):any} [computeYChange] + * @return {PModel.Node | null} + */ +const createNodeIfNotExists = (el, schema, mapping, snapshot, prevSnapshot, computeYChange) => { + const node = /** @type {PModel.Node} */ (mapping.get(el)); + if (node === undefined) { + if (el instanceof Y.XmlElement) { + return createNodeFromYElement(el, schema, mapping, snapshot, prevSnapshot, computeYChange); + } else { + throw error.methodUnimplemented(); // we are currently not handling hooks + } + } + return node; +}; + +/** + * @private + * @param {Y.XmlElement} el + * @param {any} schema + * @param {ProsemirrorMapping} mapping + * @param {Y.Snapshot} [snapshot] + * @param {Y.Snapshot} [prevSnapshot] + * @param {function('removed' | 'added', Y.ID):any} [computeYChange] + * @return {PModel.Node | null} Returns node if node could be created. Otherwise it deletes the yjs type and returns null + */ +const createNodeFromYElement = (el, schema, mapping, snapshot, prevSnapshot, computeYChange) => { + const children = []; + const createChildren = (type) => { + if (type.constructor === Y.XmlElement) { + const n = createNodeIfNotExists(type, schema, mapping, snapshot, prevSnapshot, computeYChange); + if (n !== null) { + children.push(n); + } + } else { + const ns = createTextNodesFromYText(type, schema, mapping, snapshot, prevSnapshot, computeYChange); + if (ns !== null) { + ns.forEach((textchild) => { + if (textchild !== null) { + children.push(textchild); + } + }); + } + } + }; + if (snapshot === undefined || prevSnapshot === undefined) { + el.toArray().forEach(createChildren); + } else { + Y.typeListToArraySnapshot(el, new Y.Snapshot(prevSnapshot.ds, snapshot.sv)).forEach(createChildren); + } + try { + const attrs = el.getAttributes(snapshot); + if (snapshot !== undefined) { + if (!isVisible(/** @type {Y.Item} */ (el._item), snapshot)) { + attrs.ychange = computeYChange + ? computeYChange('removed', /** @type {Y.Item} */ (el._item).id) + : { type: 'removed' }; + } else if (!isVisible(/** @type {Y.Item} */ (el._item), prevSnapshot)) { + attrs.ychange = computeYChange + ? computeYChange('added', /** @type {Y.Item} */ (el._item).id) + : { type: 'added' }; + } + } + const node = schema.node(el.nodeName, attrs, children); + mapping.set(el, node); + return node; + } catch (e) { + // an error occured while creating the node. This is probably a result of a concurrent action. + /** @type {Y.Doc} */ (el.doc).transact((transaction) => { + /** @type {Y.Item} */ (el._item).delete(transaction); + }, ySyncPluginKey); + mapping.delete(el); + return null; + } +}; + +/** + * @private + * @param {Y.XmlText} text + * @param {any} schema + * @param {ProsemirrorMapping} mapping + * @param {Y.Snapshot} [snapshot] + * @param {Y.Snapshot} [prevSnapshot] + * @param {function('removed' | 'added', Y.ID):any} [computeYChange] + * @return {Array|null} + */ +const createTextNodesFromYText = (text, schema, mapping, snapshot, prevSnapshot, computeYChange) => { + const nodes = []; + const deltas = text.toDelta(snapshot, prevSnapshot, computeYChange); + try { + for (let i = 0; i < deltas.length; i++) { + const delta = deltas[i]; + const marks = []; + for (const markName in delta.attributes) { + marks.push(schema.mark(markName, delta.attributes[markName])); + } + nodes.push(schema.text(delta.insert, marks)); + } + } catch (e) { + // an error occured while creating the node. This is probably a result of a concurrent action. + /** @type {Y.Doc} */ (text.doc).transact((transaction) => { + /** @type {Y.Item} */ (text._item).delete(transaction); + }, ySyncPluginKey); + return null; + } + // @ts-ignore + return nodes; +}; + +/** + * @private + * @param {Array} nodes prosemirror node + * @param {ProsemirrorMapping} mapping + * @return {Y.XmlText} + */ +const createTypeFromTextNodes = (nodes, mapping) => { + const type = new Y.XmlText(); + const delta = nodes.map((node) => ({ + // @ts-ignore + insert: node.text, + attributes: marksToAttributes(node.marks), + })); + type.applyDelta(delta); + mapping.set(type, nodes); + return type; +}; + +/** + * @private + * @param {any} node prosemirror node + * @param {ProsemirrorMapping} mapping + * @return {Y.XmlElement} + */ +const createTypeFromElementNode = (node, mapping) => { + const type = new Y.XmlElement(node.type.name); + for (const key in node.attrs) { + const val = node.attrs[key]; + if (val !== null && key !== 'ychange') { + type.setAttribute(key, val); + } + } + type.insert( + 0, + normalizePNodeContent(node).map((n) => createTypeFromTextOrElementNode(n, mapping)) + ); + mapping.set(type, node); + return type; +}; + +/** + * @private + * @param {PModel.Node|Array} node prosemirror text node + * @param {ProsemirrorMapping} mapping + * @return {Y.XmlElement|Y.XmlText} + */ +const createTypeFromTextOrElementNode = (node, mapping) => + node instanceof Array ? createTypeFromTextNodes(node, mapping) : createTypeFromElementNode(node, mapping); + +const isObject = (val) => typeof val === 'object' && val !== null; + +const equalAttrs = (pattrs, yattrs) => { + const keys = Object.keys(pattrs).filter((key) => pattrs[key] !== null); + let eq = keys.length === Object.keys(yattrs).filter((key) => yattrs[key] !== null).length; + for (let i = 0; i < keys.length && eq; i++) { + const key = keys[i]; + const l = pattrs[key]; + const r = yattrs[key]; + eq = key === 'ychange' || l === r || (isObject(l) && isObject(r) && equalAttrs(l, r)); + } + return eq; +}; + +/** + * @typedef {Array|PModel.Node>} NormalizedPNodeContent + */ + +/** + * @param {any} pnode + * @return {NormalizedPNodeContent} + */ +const normalizePNodeContent = (pnode) => { + const c = pnode.content.content; + const res = []; + for (let i = 0; i < c.length; i++) { + const n = c[i]; + if (n.isText) { + const textNodes = []; + for (let tnode = c[i]; i < c.length && tnode.isText; tnode = c[++i]) { + textNodes.push(tnode); + } + i--; + res.push(textNodes); + } else { + res.push(n); + } + } + return res; +}; + +/** + * @param {Y.XmlText} ytext + * @param {Array} ptexts + */ +const equalYTextPText = (ytext, ptexts) => { + const delta = ytext.toDelta(); + return ( + delta.length === ptexts.length && + delta.every( + (d, i) => + d.insert === /** @type {any} */ (ptexts[i]).text && + object.keys(d.attributes || {}).length === ptexts[i].marks.length && + ptexts[i].marks.every((mark) => equalAttrs(d.attributes[mark.type.name] || {}, mark.attrs)) + ) + ); +}; + +/** + * @param {Y.XmlElement|Y.XmlText|Y.XmlHook} ytype + * @param {any|Array} pnode + */ +const equalYTypePNode = (ytype, pnode) => { + if (ytype instanceof Y.XmlElement && !(pnode instanceof Array) && matchNodeName(ytype, pnode)) { + const normalizedContent = normalizePNodeContent(pnode); + return ( + ytype._length === normalizedContent.length && + equalAttrs(ytype.getAttributes(), pnode.attrs) && + ytype.toArray().every((ychild, i) => equalYTypePNode(ychild, normalizedContent[i])) + ); + } + return ytype instanceof Y.XmlText && pnode instanceof Array && equalYTextPText(ytype, pnode); +}; + +/** + * @param {PModel.Node | Array | undefined} mapped + * @param {PModel.Node | Array} pcontent + */ +const mappedIdentity = (mapped, pcontent) => + mapped === pcontent || + (mapped instanceof Array && + pcontent instanceof Array && + mapped.length === pcontent.length && + mapped.every((a, i) => pcontent[i] === a)); + +/** + * @param {Y.XmlElement} ytype + * @param {PModel.Node} pnode + * @param {ProsemirrorMapping} mapping + * @return {{ foundMappedChild: boolean, equalityFactor: number }} + */ +const computeChildEqualityFactor = (ytype, pnode, mapping) => { + const yChildren = ytype.toArray(); + const pChildren = normalizePNodeContent(pnode); + const pChildCnt = pChildren.length; + const yChildCnt = yChildren.length; + const minCnt = math.min(yChildCnt, pChildCnt); + let left = 0; + let right = 0; + let foundMappedChild = false; + for (; left < minCnt; left++) { + const leftY = yChildren[left]; + const leftP = pChildren[left]; + if (mappedIdentity(mapping.get(leftY), leftP)) { + foundMappedChild = true; // definite (good) match! + } else if (!equalYTypePNode(leftY, leftP)) { + break; + } + } + for (; left + right < minCnt; right++) { + const rightY = yChildren[yChildCnt - right - 1]; + const rightP = pChildren[pChildCnt - right - 1]; + if (mappedIdentity(mapping.get(rightY), rightP)) { + foundMappedChild = true; + } else if (!equalYTypePNode(rightY, rightP)) { + break; + } + } + return { + equalityFactor: left + right, + foundMappedChild, + }; +}; + +const ytextTrans = (ytext) => { + let str = ''; + /** + * @type {Y.Item|null} + */ + let n = ytext._start; + const nAttrs = {}; + while (n !== null) { + if (!n.deleted) { + if (n.countable && n.content instanceof Y.ContentString) { + str += n.content.str; + } else if (n.content instanceof Y.ContentFormat) { + nAttrs[n.content.key] = null; + } + } + n = n.right; + } + return { + str, + nAttrs, + }; +}; + +/** + * @todo test this more + * + * @param {Y.Text} ytext + * @param {Array} ptexts + * @param {ProsemirrorMapping} mapping + */ +const updateYText = (ytext, ptexts, mapping) => { + mapping.set(ytext, ptexts); + const { nAttrs, str } = ytextTrans(ytext); + const content = ptexts.map((p) => ({ + insert: /** @type {any} */ (p).text, + attributes: Object.assign({}, nAttrs, marksToAttributes(p.marks)), + })); + const { insert, remove, index } = simpleDiff(str, content.map((c) => c.insert).join('')); + ytext.delete(index, remove); + ytext.insert(index, insert); + ytext.applyDelta(content.map((c) => ({ retain: c.insert.length, attributes: c.attributes }))); +}; + +const marksToAttributes = (marks) => { + const pattrs = {}; + marks.forEach((mark) => { + if (mark.type.name !== 'ychange') { + pattrs[mark.type.name] = mark.attrs; + } + }); + return pattrs; +}; + +/** + * @private + * @param {Y.Doc} y + * @param {Y.XmlFragment} yDomFragment + * @param {any} pNode + * @param {ProsemirrorMapping} mapping + */ +export const updateYFragment = (y, yDomFragment, pNode, mapping) => { + if (yDomFragment instanceof Y.XmlElement && yDomFragment.nodeName !== pNode.type.name) { + throw new Error('node name mismatch!'); + } + mapping.set(yDomFragment, pNode); + // update attributes + if (yDomFragment instanceof Y.XmlElement) { + const yDomAttrs = yDomFragment.getAttributes(); + const pAttrs = pNode.attrs; + for (const key in pAttrs) { + if (pAttrs[key] !== null) { + if (yDomAttrs[key] !== pAttrs[key] && key !== 'ychange') { + yDomFragment.setAttribute(key, pAttrs[key]); + } + } else { + yDomFragment.removeAttribute(key); + } + } + // remove all keys that are no longer in pAttrs + for (const key in yDomAttrs) { + if (pAttrs[key] === undefined) { + yDomFragment.removeAttribute(key); + } + } + } + // update children + const pChildren = normalizePNodeContent(pNode); + const pChildCnt = pChildren.length; + const yChildren = yDomFragment.toArray(); + const yChildCnt = yChildren.length; + const minCnt = math.min(pChildCnt, yChildCnt); + let left = 0; + let right = 0; + // find number of matching elements from left + for (; left < minCnt; left++) { + const leftY = yChildren[left]; + const leftP = pChildren[left]; + if (!mappedIdentity(mapping.get(leftY), leftP)) { + if (equalYTypePNode(leftY, leftP)) { + // update mapping + mapping.set(leftY, leftP); + } else { + break; + } + } + } + // find number of matching elements from right + for (; right + left + 1 < minCnt; right++) { + const rightY = yChildren[yChildCnt - right - 1]; + const rightP = pChildren[pChildCnt - right - 1]; + if (!mappedIdentity(mapping.get(rightY), rightP)) { + if (equalYTypePNode(rightY, rightP)) { + // update mapping + mapping.set(rightY, rightP); + } else { + break; + } + } + } + y.transact(() => { + // try to compare and update + while (yChildCnt - left - right > 0 && pChildCnt - left - right > 0) { + const leftY = yChildren[left]; + const leftP = pChildren[left]; + const rightY = yChildren[yChildCnt - right - 1]; + const rightP = pChildren[pChildCnt - right - 1]; + if (leftY instanceof Y.XmlText && leftP instanceof Array) { + if (!equalYTextPText(leftY, leftP)) { + updateYText(leftY, leftP, mapping); + } + left += 1; + } else { + let updateLeft = leftY instanceof Y.XmlElement && matchNodeName(leftY, leftP); + let updateRight = rightY instanceof Y.XmlElement && matchNodeName(rightY, rightP); + if (updateLeft && updateRight) { + // decide which which element to update + const equalityLeft = computeChildEqualityFactor( + /** @type {Y.XmlElement} */ (leftY), + /** @type {PModel.Node} */ (leftP), + mapping + ); + const equalityRight = computeChildEqualityFactor( + /** @type {Y.XmlElement} */ (rightY), + /** @type {PModel.Node} */ (rightP), + mapping + ); + if (equalityLeft.foundMappedChild && !equalityRight.foundMappedChild) { + updateRight = false; + } else if (!equalityLeft.foundMappedChild && equalityRight.foundMappedChild) { + updateLeft = false; + } else if (equalityLeft.equalityFactor < equalityRight.equalityFactor) { + updateLeft = false; + } else { + updateRight = false; + } + } + if (updateLeft) { + updateYFragment(y, /** @type {Y.XmlFragment} */ (leftY), /** @type {PModel.Node} */ (leftP), mapping); + left += 1; + } else if (updateRight) { + updateYFragment(y, /** @type {Y.XmlFragment} */ (rightY), /** @type {PModel.Node} */ (rightP), mapping); + right += 1; + } else { + yDomFragment.delete(left, 1); + yDomFragment.insert(left, [createTypeFromTextOrElementNode(leftP, mapping)]); + left += 1; + } + } + } + const yDelLen = yChildCnt - left - right; + if (yDelLen > 0) { + yDomFragment.delete(left, yDelLen); + } + if (left + right < pChildCnt) { + const ins = []; + for (let i = left; i < pChildCnt - right; i++) { + ins.push(createTypeFromTextOrElementNode(pChildren[i], mapping)); + } + yDomFragment.insert(left, ins); + } + }, ySyncPluginKey); +}; + +/** + * @function + * @param {Y.XmlElement} yElement + * @param {any} pNode Prosemirror Node + */ +const matchNodeName = (yElement, pNode) => !(pNode instanceof Array) && yElement.nodeName === pNode.type.name; diff --git a/packages/client/src/tiptap/core/y-prosemirror/plugins/undo-plugin.js b/packages/client/src/tiptap/core/y-prosemirror/plugins/undo-plugin.js new file mode 100644 index 00000000..c811bb28 --- /dev/null +++ b/packages/client/src/tiptap/core/y-prosemirror/plugins/undo-plugin.js @@ -0,0 +1,100 @@ +import { Plugin } from 'prosemirror-state'; // eslint-disable-line + +import { getRelativeSelection } from './sync-plugin.js'; +import { UndoManager, Item, ContentType, XmlElement, Text } from 'yjs'; +import { yUndoPluginKey, ySyncPluginKey } from './keys.js'; + +export const undo = (state) => { + const undoManager = yUndoPluginKey.getState(state).undoManager; + if (undoManager != null) { + undoManager.undo(); + return true; + } +}; + +export const redo = (state) => { + const undoManager = yUndoPluginKey.getState(state).undoManager; + if (undoManager != null) { + undoManager.redo(); + return true; + } +}; + +export const defaultProtectedNodes = new Set(['paragraph']); + +export const defaultDeleteFilter = (item, protectedNodes) => + !(item instanceof Item) || + !(item.content instanceof ContentType) || + !( + item.content.type instanceof Text || + (item.content.type instanceof XmlElement && protectedNodes.has(item.content.type.nodeName)) + ) || + item.content.type._length === 0; + +export const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins = [], undoManager = null } = {}) => + new Plugin({ + key: yUndoPluginKey, + state: { + init: (initargs, state) => { + // TODO: check if plugin order matches and fix + const ystate = ySyncPluginKey.getState(state); + const _undoManager = + undoManager || + new UndoManager(ystate.type, { + trackedOrigins: new Set([ySyncPluginKey].concat(trackedOrigins)), + deleteFilter: (item) => defaultDeleteFilter(item, protectedNodes), + }); + return { + undoManager: _undoManager, + prevSel: null, + hasUndoOps: _undoManager.undoStack.length > 0, + hasRedoOps: _undoManager.redoStack.length > 0, + }; + }, + apply: (tr, val, oldState, state) => { + const binding = ySyncPluginKey.getState(state).binding; + const undoManager = val.undoManager; + const hasUndoOps = undoManager.undoStack.length > 0; + const hasRedoOps = undoManager.redoStack.length > 0; + if (binding) { + return { + undoManager, + prevSel: getRelativeSelection(binding, oldState), + hasUndoOps, + hasRedoOps, + }; + } else { + if (hasUndoOps !== val.hasUndoOps || hasRedoOps !== val.hasRedoOps) { + return Object.assign({}, val, { + hasUndoOps: undoManager.undoStack.length > 0, + hasRedoOps: undoManager.redoStack.length > 0, + }); + } else { + // nothing changed + return val; + } + } + }, + }, + view: (view) => { + const ystate = ySyncPluginKey.getState(view.state); + const undoManager = yUndoPluginKey.getState(view.state).undoManager; + undoManager.on('stack-item-added', ({ stackItem }) => { + const binding = ystate.binding; + if (binding) { + stackItem.meta.set(binding, yUndoPluginKey.getState(view.state).prevSel); + } + }); + undoManager.on('stack-item-popped', ({ stackItem }) => { + const binding = ystate.binding; + if (binding) { + binding.beforeTransactionSelection = stackItem.meta.get(binding) || binding.beforeTransactionSelection; + } + }); + return { + destroy: () => { + undoManager.destroy(); + }, + }; + }, + }); diff --git a/packages/client/src/tiptap/core/y-prosemirror/y-prosemirror.js b/packages/client/src/tiptap/core/y-prosemirror/y-prosemirror.js new file mode 100644 index 00000000..4ed37dec --- /dev/null +++ b/packages/client/src/tiptap/core/y-prosemirror/y-prosemirror.js @@ -0,0 +1,13 @@ +export { + absolutePositionToRelativePosition, + prosemirrorJSONToYDoc, + prosemirrorToYDoc, + relativePositionToAbsolutePosition, + setMeta, + yDocToProsemirror, + yDocToProsemirrorJSON, +} from './lib.js'; +export * from './plugins/cursor-plugin.js'; +export * from './plugins/keys.js'; +export { getRelativeSelection, isVisible, ProsemirrorBinding, ySyncPlugin } from './plugins/sync-plugin.js'; +export * from './plugins/undo-plugin.js'; diff --git a/packages/client/src/tiptap/editor/collaboration/collaboration/index.tsx b/packages/client/src/tiptap/editor/collaboration/collaboration/index.tsx index 85c9d0b8..7499634a 100644 --- a/packages/client/src/tiptap/editor/collaboration/collaboration/index.tsx +++ b/packages/client/src/tiptap/editor/collaboration/collaboration/index.tsx @@ -5,7 +5,7 @@ import { debounce } from 'helpers/debounce'; import { useToggle } from 'hooks/use-toggle'; import { SecureDocumentIllustration } from 'illustrations/secure-document'; import React, { forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react'; -import { IndexeddbPersistence } from 'y-indexeddb'; +import { IndexeddbPersistence } from 'tiptap/core/y-indexeddb'; import { Editor } from '../../react'; import { EditorInstance } from './editor'; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index e705bb78..2e0942f9 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -4,6 +4,7 @@ importers: .: specifiers: + '@types/node': ^17.0.35 concurrently: ^7.0.0 cross-env: ^7.0.3 fs-extra: ^10.0.0 @@ -25,6 +26,7 @@ importers: fs-extra: 10.0.0 rimraf: 3.0.2 devDependencies: + '@types/node': 17.0.35 husky: 7.0.4 lint-staged: 12.4.1 prettier: 2.5.1 @@ -91,6 +93,7 @@ importers: axios: ^0.25.0 classnames: ^2.3.1 clone: ^2.1.2 + copy-webpack-plugin: 11.0.0 cross-env: ^7.0.3 deep-equal: ^2.0.5 dompurify: ^2.3.5 @@ -101,6 +104,7 @@ importers: eslint-plugin-react: ^7.29.4 eslint-plugin-react-hooks: ^4.5.0 eslint-plugin-simple-import-sort: ^7.0.0 + fs-extra: ^10.0.0 interactjs: ^1.10.11 katex: ^0.15.2 lib0: ^0.2.47 @@ -112,7 +116,7 @@ importers: markdown-it-sub: ^1.0.0 markdown-it-sup: ^1.0.0 next: 12.0.10 - next-offline: ^5.0.5 + next-pwa: ^5.5.2 prosemirror-markdown: ^1.7.0 prosemirror-model: ^1.16.1 prosemirror-schema-list: ^1.1.6 @@ -136,8 +140,7 @@ importers: tsconfig-paths-webpack-plugin: ^3.5.2 typescript: 4.5.5 viewerjs: ^1.10.4 - y-indexeddb: ^9.0.7 - y-prosemirror: ^1.0.14 + workbox-webpack-plugin: ^6.5.3 yjs: ^13.5.24 dependencies: '@douyinfe/semi-icons': 2.3.1_react@17.0.2 @@ -202,7 +205,7 @@ importers: markdown-it-sub: 1.0.0 markdown-it-sup: 1.0.0 next: 12.0.10_react-dom@17.0.2+react@17.0.2 - next-offline: 5.0.5_next@12.0.10 + next-pwa: 5.5.2_next@12.0.10 prosemirror-markdown: 1.7.0 prosemirror-model: 1.16.1 prosemirror-schema-list: 1.1.6 @@ -224,23 +227,24 @@ importers: tippy.js: 6.3.7 toggle-selection: 1.0.6 viewerjs: 1.10.4 - y-indexeddb: 9.0.7_yjs@13.5.24 - y-prosemirror: 1.0.14_50c74ca1ff175066b565400fd8b84eb4 yjs: 13.5.24 devDependencies: '@types/node': 17.0.13 '@types/react': 17.0.38 '@typescript-eslint/eslint-plugin': 5.21.0_19515efd875c7ffcd67055d8be736b9f '@typescript-eslint/parser': 5.21.0_eslint@8.14.0+typescript@4.5.5 + copy-webpack-plugin: 11.0.0 eslint: 8.14.0 eslint-config-prettier: 8.5.0_eslint@8.14.0 eslint-plugin-import: 2.26.0_eslint@8.14.0 - eslint-plugin-prettier: 4.0.0_740be41c8168d0cc214a306089357ad0 + eslint-plugin-prettier: 4.0.0_74ebb802163a9b4fa8f89d76ed02f62a eslint-plugin-react: 7.29.4_eslint@8.14.0 eslint-plugin-react-hooks: 4.5.0_eslint@8.14.0 eslint-plugin-simple-import-sort: 7.0.0_eslint@8.14.0 + fs-extra: 10.0.0 tsconfig-paths-webpack-plugin: 3.5.2 typescript: 4.5.5 + workbox-webpack-plugin: 6.5.3 packages/config: specifiers: @@ -488,6 +492,17 @@ packages: - chokidar dev: true + /@apideck/better-ajv-errors/0.3.3_ajv@8.8.2: + resolution: {integrity: sha512-9o+HO2MbJhJHjDYZaDxJmSDckvDpiuItEsrIShV0DXeCshXWRHhqYyU/PKHMkuClOmFnZhRd6wzv4vpDu/dRKg==} + engines: {node: '>=10'} + peerDependencies: + ajv: '>=8' + dependencies: + ajv: 8.8.2 + json-schema: 0.4.0 + jsonpointer: 5.0.0 + leven: 3.1.0 + /@babel/code-frame/7.16.7: resolution: {integrity: sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg==} engines: {node: '>=6.9.0'} @@ -501,7 +516,6 @@ packages: /@babel/compat-data/7.17.10: resolution: {integrity: sha512-GZt/TCsG70Ms19gfZO1tM4CVnXsPgEPBCpJu+Qz3L0LUDsY5nZqFZglIoPC1kIYOtNBZlrnFT+klg12vFGZXrw==} engines: {node: '>=6.9.0'} - dev: false /@babel/core/7.16.12: resolution: {integrity: sha512-dK5PtG1uiN2ikk++5OzSYsitZKny4wOCD0nrO4TqnW4BVBTQ2NGS3NgilvT/TEyxTST7LNyWV/T4tXDoD3fOgg==} @@ -540,14 +554,12 @@ packages: '@babel/types': 7.17.12 '@jridgewell/gen-mapping': 0.3.1 jsesc: 2.5.2 - dev: false /@babel/helper-annotate-as-pure/7.16.7: resolution: {integrity: sha512-s6t2w/IPQVTAET1HitoowRGXooX8mCgtuP5195wD/QJPV6wYjpujCGF7JuMODVX2ZAJOf1GT6DT9MHEZvLOFSw==} engines: {node: '>=6.9.0'} dependencies: '@babel/types': 7.17.12 - dev: false /@babel/helper-builder-binary-assignment-operator-visitor/7.16.7: resolution: {integrity: sha512-C6FdbRaxYjwVu/geKW4ZeQ0Q31AftgRcdSnZ5/jsH6BzCJbtvXvhpfkbkThYSuutZA7nCXpPR6AD9zd1dprMkA==} @@ -555,7 +567,6 @@ packages: dependencies: '@babel/helper-explode-assignable-expression': 7.16.7 '@babel/types': 7.17.12 - dev: false /@babel/helper-compilation-targets/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-mGojBwIWcwGD6rfqgRXVlVYmPAv7eOpIemUG3dGnDdCY4Pae70ROij3XmfrH6Fa1h1aiDylpglbZyktfzyo/hA==} @@ -580,7 +591,6 @@ packages: '@babel/helper-validator-option': 7.16.7 browserslist: 4.20.3 semver: 6.3.0 - dev: false /@babel/helper-create-class-features-plugin/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-sZoOeUTkFJMyhqCei2+Z+wtH/BehW8NVKQt7IRUQlRiOARuXymJYfN/FCcI8CvVbR0XVyDM6eLFOlR7YtiXnew==} @@ -598,7 +608,6 @@ packages: '@babel/helper-split-export-declaration': 7.16.7 transitivePeerDependencies: - supports-color - dev: false /@babel/helper-create-regexp-features-plugin/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-b2aZrV4zvutr9AIa6/gA3wsZKRwTKYoDxYiFKcESS3Ug2GTXzwBEvMuuFLhCQpEnRXs1zng4ISAXSUxxKBIcxw==} @@ -609,7 +618,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-annotate-as-pure': 7.16.7 regexpu-core: 5.0.1 - dev: false /@babel/helper-define-polyfill-provider/0.3.1_@babel+core@7.16.12: resolution: {integrity: sha512-J9hGMpJQmtWmj46B3kBHmL38UhJGhYX7eqkcq+2gsstyYt341HmPeWspihX43yVRA0mS+8GGk2Gckc7bY/HCmA==} @@ -627,7 +635,6 @@ packages: semver: 6.3.0 transitivePeerDependencies: - supports-color - dev: false /@babel/helper-environment-visitor/7.16.7: resolution: {integrity: sha512-SLLb0AAn6PkUeAfKJCCOl9e1R53pQlGAfc4y4XuMRZfqeMYLE0dM1LMhqbGAlGQY0lfw5/ohoYWAe9V1yibRag==} @@ -640,7 +647,6 @@ packages: engines: {node: '>=6.9.0'} dependencies: '@babel/types': 7.17.12 - dev: false /@babel/helper-function-name/7.16.7: resolution: {integrity: sha512-QfDfEnIUyyBSR3HtrtGECuZ6DAyCkYFp7GHl75vFtTnn6pjKeK0T1DB5lLkFvBea8MdaiUABx3osbgLyInoejA==} @@ -656,7 +662,6 @@ packages: dependencies: '@babel/template': 7.16.7 '@babel/types': 7.17.12 - dev: false /@babel/helper-get-function-arity/7.16.7: resolution: {integrity: sha512-flc+RLSOBXzNzVhcLu6ujeHUrD6tANAOU5ojrRx/as+tbzf8+stUCj7+IfRRoAbEZqj/ahXEMsjhOhgeZsrnTw==} @@ -675,7 +680,6 @@ packages: engines: {node: '>=6.9.0'} dependencies: '@babel/types': 7.17.12 - dev: false /@babel/helper-module-imports/7.16.7: resolution: {integrity: sha512-LVtS6TqjJHFc+nYeITRo6VLXve70xmq7wPhWTqDJusJEgGmkAACWwMiTNrvfoQo6hEhFwAIixNkvB0jPXDL8Wg==} @@ -712,14 +716,12 @@ packages: '@babel/types': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/helper-optimise-call-expression/7.16.7: resolution: {integrity: sha512-EtgBhg7rd/JcnpZFXpBy0ze1YRfdm7BnBX4uKMBd3ixa3RGAE002JZB66FJyNH7g0F38U05pXmA5P8cBh7z+1w==} engines: {node: '>=6.9.0'} dependencies: '@babel/types': 7.17.12 - dev: false /@babel/helper-plugin-utils/7.16.7: resolution: {integrity: sha512-Qg3Nk7ZxpgMrsox6HreY1ZNKdBq7K72tDSliA6dCl5f007jR4ne8iD5UzuNnCJH2xBf2BEEVGr+/OL6Gdp7RxA==} @@ -739,7 +741,6 @@ packages: '@babel/types': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/helper-replace-supers/7.16.7: resolution: {integrity: sha512-y9vsWilTNaVnVh6xiJfABzsNpgDPKev9HnAgz6Gb1p6UUwf9NepdlsV7VXGCftJM+jqD5f7JIEubcpLjZj5dBw==} @@ -752,7 +753,6 @@ packages: '@babel/types': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/helper-simple-access/7.16.7: resolution: {integrity: sha512-ZIzHVyoeLMvXMN/vok/a4LWRy8G2v205mNP0XOuf9XRLyX5/u9CnVulUtDgUTama3lT+bf/UqucuZjqiGuTS1g==} @@ -765,14 +765,12 @@ packages: engines: {node: '>=6.9.0'} dependencies: '@babel/types': 7.17.12 - dev: false /@babel/helper-skip-transparent-expression-wrappers/7.16.0: resolution: {integrity: sha512-+il1gTy0oHwUsBQZyJvukbB4vPMdcYBrFHa0Uc4AizLxbq6BOYC51Rv4tWocX9BLBDLZ4kc6qUFpQ6HRgL+3zw==} engines: {node: '>=6.9.0'} dependencies: '@babel/types': 7.17.12 - dev: false /@babel/helper-split-export-declaration/7.16.7: resolution: {integrity: sha512-xbWoy/PFoxSWazIToT9Sif+jJTlrMcndIsaOKvTA6u7QEo7ilkRZpjew18/W3c7nm8fXdUDXh02VXTbZ0pGDNw==} @@ -798,7 +796,6 @@ packages: '@babel/types': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/helpers/7.16.7: resolution: {integrity: sha512-9ZDoqtfY7AuEOt3cxchfii6C7GDyyMBffktR5B2jvWv8u2+efwvpnVKXMWzNehqy68tKgAfSwfdw/lWpthS2bw==} @@ -827,7 +824,6 @@ packages: resolution: {integrity: sha512-FLzHmN9V3AJIrWfOpvRlZCeVg/WLdicSnTMsLur6uDj9TT8ymUlG9XxURdW/XvuygK+2CW0poOJABdA4m/YKxA==} engines: {node: '>=6.0.0'} hasBin: true - dev: false /@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-xCJQXl4EeQ3J9C4yOmpTrtVGmzpm2iSzyxbkZHw7UCnZBftHpF/hpII80uWVyVrc40ytIClHjgWGTG1g/yB+aw==} @@ -837,7 +833,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-/vt0hpIw0x4b6BLKUkwlvEoiGZYYLNZ96CzyHYPbtG2jZGz6LBe7/V+drYrc/d+ovrF9NBi0pmtvmNb/FsWtRQ==} @@ -849,7 +844,6 @@ packages: '@babel/helper-plugin-utils': 7.17.12 '@babel/helper-skip-transparent-expression-wrappers': 7.16.0 '@babel/plugin-proposal-optional-chaining': 7.17.12_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-async-generator-functions/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-RWVvqD1ooLKP6IqWTA5GyFVX2isGEgC5iFxKzfYOIy/QEFdxYyCybBDtIGjipHpb9bDWHzcqGqFakf+mVmBTdQ==} @@ -863,7 +857,6 @@ packages: '@babel/plugin-syntax-async-generators': 7.8.4_@babel+core@7.16.12 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-proposal-class-properties/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-U0mI9q8pW5Q9EaTHFPwSVusPMV/DV9Mm8p7csqROFLtIE9rBF5piLqyrBGigftALrBcsBGu4m38JneAe7ZDLXw==} @@ -876,7 +869,6 @@ packages: '@babel/helper-plugin-utils': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-proposal-class-static-block/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-8ILyDG6eL14F8iub97dVc8q35Md0PJYAnA5Kz9NACFOkt6ffCcr0FISyUPKHsvuAy36fkpIitxZ9bVYPFMGQHA==} @@ -890,7 +882,6 @@ packages: '@babel/plugin-syntax-class-static-block': 7.14.5_@babel+core@7.16.12 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-proposal-dynamic-import/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-I8SW9Ho3/8DRSdmDdH3gORdyUuYnk1m4cMxUAdu5oy4n3OfN8flDEH+d60iG7dUfi0KkYwSvoalHzzdRzpWHTg==} @@ -901,7 +892,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-dynamic-import': 7.8.3_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-export-namespace-from/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-j7Ye5EWdwoXOpRmo5QmRyHPsDIe6+u70ZYZrd7uz+ebPYFKfRcLcNu3Ro0vOlJ5zuv8rU7xa+GttNiRzX56snQ==} @@ -912,7 +902,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-export-namespace-from': 7.8.3_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-json-strings/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-rKJ+rKBoXwLnIn7n6o6fulViHMrOThz99ybH+hKHcOZbnN14VuMnH9fo2eHE69C8pO4uX1Q7t2HYYIDmv8VYkg==} @@ -923,7 +912,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-json-strings': 7.8.3_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-logical-assignment-operators/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-EqFo2s1Z5yy+JeJu7SFfbIUtToJTVlC61/C7WLKDntSw4Sz6JNAIfL7zQ74VvirxpjB5kz/kIx0gCcb+5OEo2Q==} @@ -934,7 +922,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-logical-assignment-operators': 7.10.4_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-nullish-coalescing-operator/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-ws/g3FSGVzv+VH86+QvgtuJL/kR67xaEIF2x0iPqdDfYW6ra6JF3lKVBkWynRLcNtIC1oCTfDRVxmm2mKzy+ag==} @@ -945,7 +932,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-numeric-separator/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-vQgPMknOIgiuVqbokToyXbkY/OmmjAzr/0lhSIbG/KmnzXPGwW/AdhdKpi+O4X/VkWiWjnkKOBiqJrTaC98VKw==} @@ -956,7 +942,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-numeric-separator': 7.10.4_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-object-rest-spread/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-6l9cO3YXXRh4yPCPRA776ZyJ3RobG4ZKJZhp7NDRbKIOeV3dBPG8FXCF7ZtiO2RTCIOkQOph1xDDcc01iWVNjQ==} @@ -970,7 +955,6 @@ packages: '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-object-rest-spread': 7.8.3_@babel+core@7.16.12 '@babel/plugin-transform-parameters': 7.17.12_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-optional-catch-binding/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-eMOH/L4OvWSZAE1VkHbr1vckLG1WUcHGJSLqqQwl2GaUqG6QjddvrOaTUMNYiv77H5IKPMZ9U9P7EaHwvAShfA==} @@ -981,7 +965,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/plugin-syntax-optional-catch-binding': 7.8.3_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-optional-chaining/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-7wigcOs/Z4YWlK7xxjkvaIw84vGhDv/P1dFGQap0nHkc8gFKY/r+hXc8Qzf5k1gY7CvGIcHqAnOagVKJJ1wVOQ==} @@ -993,7 +976,6 @@ packages: '@babel/helper-plugin-utils': 7.17.12 '@babel/helper-skip-transparent-expression-wrappers': 7.16.0 '@babel/plugin-syntax-optional-chaining': 7.8.3_@babel+core@7.16.12 - dev: false /@babel/plugin-proposal-private-methods/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-SllXoxo19HmxhDWm3luPz+cPhtoTSKLJE9PXshsfrOzBqs60QP0r8OaJItrPhAj0d7mZMnNF0Y1UUggCDgMz1A==} @@ -1006,7 +988,6 @@ packages: '@babel/helper-plugin-utils': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-proposal-private-property-in-object/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-/6BtVi57CJfrtDNKfK5b66ydK2J5pXUKBKSPD2G1whamMuEnZWgoOIfO8Vf9F/DoD4izBLD/Au4NMQfruzzykg==} @@ -1021,7 +1002,6 @@ packages: '@babel/plugin-syntax-private-property-in-object': 7.14.5_@babel+core@7.16.12 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-proposal-unicode-property-regex/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-Wb9qLjXf3ZazqXA7IvI7ozqRIXIGPtSo+L5coFmEkhTQK18ao4UDDD0zdTGAarmbLj2urpRwrc6893cu5Bfh0A==} @@ -1032,7 +1012,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-create-regexp-features-plugin': 7.17.12_@babel+core@7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-syntax-async-generators/7.8.4_@babel+core@7.16.12: resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} @@ -1067,7 +1046,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-syntax-dynamic-import/7.8.3_@babel+core@7.16.12: resolution: {integrity: sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==} @@ -1076,7 +1054,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-syntax-export-namespace-from/7.8.3_@babel+core@7.16.12: resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==} @@ -1085,7 +1062,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-syntax-import-meta/7.10.4_@babel+core@7.16.12: resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==} @@ -1160,7 +1136,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-syntax-top-level-await/7.14.5_@babel+core@7.16.12: resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==} @@ -1189,7 +1164,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-async-to-generator/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-J8dbrWIOO3orDzir57NRsjg4uxucvhby0L/KZuGsWDj0g7twWK3g7JhJhOrXtuXiw8MeiSdJ3E0OW9H8LYEzLQ==} @@ -1203,7 +1177,6 @@ packages: '@babel/helper-remap-async-to-generator': 7.16.8 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-block-scoped-functions/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-JUuzlzmF40Z9cXyytcbZEZKckgrQzChbQJw/5PuEHYeqzCsvebDx0K0jWnIIVcmmDOAVctCgnYs0pMcrYj2zJg==} @@ -1213,7 +1186,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-block-scoping/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-jw8XW/B1i7Lqwqj2CbrViPcZijSxfguBWZP2aN59NHgxUyO/OcO1mfdCxH13QhN5LbWhPkX+f+brKGhZTiqtZQ==} @@ -1223,7 +1195,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-classes/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-cvO7lc7pZat6BsvH6l/EGaI8zpl8paICaoGk+7x7guvtfak/TbIf66nYmJOH13EuG0H+Xx3M+9LQDtSvZFKXKw==} @@ -1242,7 +1213,6 @@ packages: globals: 11.12.0 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-computed-properties/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-a7XINeplB5cQUWMg1E/GI1tFz3LfK021IjV1rj1ypE+R7jHm+pIHmHl25VNkZxtx9uuYp7ThGk8fur1HHG7PgQ==} @@ -1252,7 +1222,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-destructuring/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-P8pt0YiKtX5UMUL5Xzsc9Oyij+pJE6JuC+F1k0/brq/OOGs5jDa1If3OY0LRWGvJsJhI+8tsiecL3nJLc0WTlg==} @@ -1262,7 +1231,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-dotall-regex/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-Lyttaao2SjZF6Pf4vk1dVKv8YypMpomAbygW+mU5cYP3S5cWTfCJjG8xV6CFdzGFlfWK81IjL9viiTvpb6G7gQ==} @@ -1273,7 +1241,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-create-regexp-features-plugin': 7.17.12_@babel+core@7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-duplicate-keys/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-EA5eYFUG6xeerdabina/xIoB95jJ17mAkR8ivx6ZSu9frKShBjpOGZPn511MTDTkiCO+zXnzNczvUM69YSf3Zw==} @@ -1283,7 +1250,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-exponentiation-operator/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-8UYLSlyLgRixQvlYH3J2ekXFHDFLQutdy7FfFAMm3CPZ6q9wHCwnUyiXpQCe3gVVnQlHc5nsuiEVziteRNTXEA==} @@ -1294,7 +1260,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-builder-binary-assignment-operator-visitor': 7.16.7 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-for-of/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-76lTwYaCxw8ldT7tNmye4LLwSoKDbRCBzu6n/DcK/P3FOR29+38CIIaVIZfwol9By8W/QHORYEnYSLuvcQKrsg==} @@ -1304,7 +1269,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-function-name/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-SU/C68YVwTRxqWj5kgsbKINakGag0KTgq9f2iZEXdStoAbOzLHEBRYzImmA6yFo8YZhJVflvXmIHUO7GWHmxxA==} @@ -1316,7 +1280,6 @@ packages: '@babel/helper-compilation-targets': 7.17.10_@babel+core@7.16.12 '@babel/helper-function-name': 7.16.7 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-literals/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-8iRkvaTjJciWycPIZ9k9duu663FT7VrBdNqNgxnVXEFwOIp55JWcZd23VBRySYbnS3PwQ3rGiabJBBBGj5APmQ==} @@ -1326,7 +1289,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-member-expression-literals/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-mBruRMbktKQwbxaJof32LT9KLy2f3gH+27a5XSuXo6h7R3vqltl0PgZ80C8ZMKw98Bf8bqt6BEVi3svOh2PzMw==} @@ -1336,7 +1298,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-modules-amd/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-p5rt9tB5Ndcc2Za7CeNxVf7YAjRcUMR6yi8o8tKjb9KhRkEvXwa+C0hj6DA5bVDkKRxB0NYhMUGbVKoFu4+zEA==} @@ -1350,7 +1311,6 @@ packages: babel-plugin-dynamic-import-node: 2.3.3 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-modules-commonjs/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-tVPs6MImAJz+DiX8Y1xXEMdTk5Lwxu9jiPjlS+nv5M2A59R7+/d1+9A8C/sbuY0b3QjIxqClkj6KAplEtRvzaA==} @@ -1365,7 +1325,6 @@ packages: babel-plugin-dynamic-import-node: 2.3.3 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-modules-systemjs/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-NVhDb0q00hqZcuLduUf/kMzbOQHiocmPbIxIvk23HLiEqaTKC/l4eRxeC7lO63M72BmACoiKOcb9AkOAJRerpw==} @@ -1381,7 +1340,6 @@ packages: babel-plugin-dynamic-import-node: 2.3.3 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-modules-umd/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-BnsPkrUHsjzZGpnrmJeDFkOMMljWFHPjDc9xDcz71/C+ybF3lfC3V4m3dwXPLZrE5b3bgd4V+3/Pj+3620d7IA==} @@ -1394,7 +1352,6 @@ packages: '@babel/helper-plugin-utils': 7.17.12 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-named-capturing-groups-regex/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-vWoWFM5CKaTeHrdUJ/3SIOTRV+MBVGybOC9mhJkaprGNt5demMymDW24yC74avb915/mIRe3TgNb/d8idvnCRA==} @@ -1405,7 +1362,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-create-regexp-features-plugin': 7.17.12_@babel+core@7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-new-target/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-CaOtzk2fDYisbjAD4Sd1MTKGVIpRtx9bWLyj24Y/k6p4s4gQ3CqDGJauFJxt8M/LEx003d0i3klVqnN73qvK3w==} @@ -1415,7 +1371,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-object-super/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-14J1feiQVWaGvRxj2WjyMuXS2jsBkgB3MdSN5HuC2G5nRspa5RK9COcs82Pwy5BuGcjb+fYaUj94mYcOj7rCvw==} @@ -1428,7 +1383,6 @@ packages: '@babel/helper-replace-supers': 7.16.7 transitivePeerDependencies: - supports-color - dev: false /@babel/plugin-transform-parameters/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-6qW4rWo1cyCdq1FkYri7AHpauchbGLXpdwnYsfxFb+KtddHENfsY5JZb35xUwkK5opOLcJ3BNd2l7PhRYGlwIA==} @@ -1438,7 +1392,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-property-literals/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-z4FGr9NMGdoIl1RqavCqGG+ZuYjfZ/hkCIeuH6Do7tXmSm0ls11nYVSJqFEUOSJbDab5wC6lRE/w6YjVcr6Hqw==} @@ -1448,7 +1401,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-regenerator/7.17.9_@babel+core@7.16.12: resolution: {integrity: sha512-Lc2TfbxR1HOyn/c6b4Y/b6NHoTb67n/IoWLxTu4kC7h4KQnWlhCq2S8Tx0t2SVvv5Uu87Hs+6JEJ5kt2tYGylQ==} @@ -1458,7 +1410,6 @@ packages: dependencies: '@babel/core': 7.16.12 regenerator-transform: 0.15.0 - dev: false /@babel/plugin-transform-reserved-words/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-1KYqwbJV3Co03NIi14uEHW8P50Md6KqFgt0FfpHdK6oyAHQVTosgPuPSiWud1HX0oYJ1hGRRlk0fP87jFpqXZA==} @@ -1468,7 +1419,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-shorthand-properties/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-hah2+FEnoRoATdIb05IOXf+4GzXYTq75TVhIn1PewihbpyrNWUt2JbudKQOETWw6QpLe+AIUpJ5MVLYTQbeeUg==} @@ -1478,7 +1428,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-spread/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-9pgmuQAtFi3lpNUstvG9nGfk9DkrdmWNp9KeKPFmuZCpEnxRzYlS8JgwPjYj+1AWDOSvoGN0H30p1cBOmT/Svg==} @@ -1489,7 +1438,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 '@babel/helper-skip-transparent-expression-wrappers': 7.16.0 - dev: false /@babel/plugin-transform-sticky-regex/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-NJa0Bd/87QV5NZZzTuZG5BPJjLYadeSZ9fO6oOUoL4iQx+9EEuw/eEM92SrsT19Yc2jgB1u1hsjqDtH02c3Drw==} @@ -1499,7 +1447,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-template-literals/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-kAKJ7DX1dSRa2s7WN1xUAuaQmkTpN+uig4wCKWivVXIObqGbVTUlSavHyfI2iZvz89GFAMGm9p2DBJ4Y1Tp0hw==} @@ -1509,7 +1456,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-typeof-symbol/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-Q8y+Jp7ZdtSPXCThB6zjQ74N3lj0f6TDh1Hnf5B+sYlzQ8i5Pjp8gW0My79iekSpT4WnI06blqP6DT0OmaXXmw==} @@ -1519,7 +1465,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-unicode-escapes/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-TAV5IGahIz3yZ9/Hfv35TV2xEm+kaBDaZQCn2S/hG9/CZ0DktxJv9eKfPc7yYCvOYR4JGx1h8C+jcSOvgaaI/Q==} @@ -1529,7 +1474,6 @@ packages: dependencies: '@babel/core': 7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/plugin-transform-unicode-regex/7.16.7_@babel+core@7.16.12: resolution: {integrity: sha512-oC5tYYKw56HO75KZVLQ+R/Nl3Hro9kf8iG0hXoaHP7tjAyCpvqBiSNe6vGrZni1Z6MggmUOC6A7VP7AVmw225Q==} @@ -1540,7 +1484,6 @@ packages: '@babel/core': 7.16.12 '@babel/helper-create-regexp-features-plugin': 7.17.12_@babel+core@7.16.12 '@babel/helper-plugin-utils': 7.17.12 - dev: false /@babel/preset-env/7.17.12_@babel+core@7.16.12: resolution: {integrity: sha512-Kke30Rj3Lmcx97bVs71LO0s8M6FmJ7tUAQI9fNId62rf0cYG1UAWwdNO9/sE0/pLEahAw1MqMorymoD12bj5Fg==} @@ -1625,7 +1568,6 @@ packages: semver: 6.3.0 transitivePeerDependencies: - supports-color - dev: false /@babel/preset-modules/0.1.5_@babel+core@7.16.12: resolution: {integrity: sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==} @@ -1638,7 +1580,6 @@ packages: '@babel/plugin-transform-dotall-regex': 7.16.7_@babel+core@7.16.12 '@babel/types': 7.17.12 esutils: 2.0.3 - dev: false /@babel/runtime-corejs3/7.16.8: resolution: {integrity: sha512-3fKhuICS1lMz0plI5ktOE/yEtBRMVxplzRkdn6mJQ197XiY0JnrzYV0+Mxozq3JZ8SBV9Ecurmw1XsGbwOf+Sg==} @@ -1653,7 +1594,6 @@ packages: engines: {node: '>=6.9.0'} dependencies: regenerator-runtime: 0.13.9 - dev: false /@babel/template/7.16.7: resolution: {integrity: sha512-I8j/x8kHUrbYRTUxXrrMbfCa7jxkE7tZre39x3kjr9hvI82cK1FfqLygotcWN5kdPGWcLdWMHpSBavse5tWw3w==} @@ -1696,7 +1636,6 @@ packages: globals: 11.12.0 transitivePeerDependencies: - supports-color - dev: false /@babel/types/7.16.8: resolution: {integrity: sha512-smN2DQc5s4M7fntyjGtyIPbRJv6wW4rU/94fmYJ7PKQuZkC0qGMHXJbg6sNGt12JmVr4k5YaptI/XtiLJBnmIg==} @@ -1877,38 +1816,6 @@ packages: - supports-color dev: true - /@hapi/address/2.1.4: - resolution: {integrity: sha512-QD1PhQk+s31P1ixsX0H0Suoupp3VMXzIVMSwobR3F3MSUO2YCV0B7xqLcUw/Bh8yuvd3LhpyqLQWTNcRmp6IdQ==} - deprecated: Moved to 'npm install @sideway/address' - dev: false - - /@hapi/bourne/1.3.2: - resolution: {integrity: sha512-1dVNHT76Uu5N3eJNTYcvxee+jzX4Z9lfciqRRHCU27ihbUcYi+iSc2iml5Ke1LXe1SyJCLA0+14Jh4tXJgOppA==} - deprecated: This version has been deprecated and is no longer supported or maintained - dev: false - - /@hapi/hoek/8.5.1: - resolution: {integrity: sha512-yN7kbciD87WzLGc5539Tn0sApjyiGHAJgKvG9W8C7O+6c7qmoQMfVs0W4bX17eqz6C78QJqqFrtgdK5EWf6Qow==} - deprecated: This version has been deprecated and is no longer supported or maintained - dev: false - - /@hapi/joi/15.1.1: - resolution: {integrity: sha512-entf8ZMOK8sc+8YfeOlM8pCfg3b5+WZIKBfUaaJT8UsjAAPjartzxIYm3TIbjvA4u+u++KbcXD38k682nVHDAQ==} - deprecated: Switch to 'npm install joi' - dependencies: - '@hapi/address': 2.1.4 - '@hapi/bourne': 1.3.2 - '@hapi/hoek': 8.5.1 - '@hapi/topo': 3.1.6 - dev: false - - /@hapi/topo/3.1.6: - resolution: {integrity: sha512-tAag0jEcjwH+P2quUfipd7liWCNX2F8NvYjQp2wtInsZxnMlypdw0FtAOLxtvvkO+GSRRbmNi8m/5y42PQJYCQ==} - deprecated: This version has been deprecated and is no longer supported or maintained - dependencies: - '@hapi/hoek': 8.5.1 - dev: false - /@hocuspocus/common/1.0.0-alpha.4: resolution: {integrity: sha512-LvKj+ASSWnvjFB7n2bl7BUGFKF9XFFP1oA3/XmKl3c7wUIvoN1Ir3sX8XnN6qBA3S2CoruEHHk+KPS6zMSMfHA==} dev: false @@ -2192,28 +2099,23 @@ packages: '@jridgewell/set-array': 1.1.1 '@jridgewell/sourcemap-codec': 1.4.13 '@jridgewell/trace-mapping': 0.3.13 - dev: false /@jridgewell/resolve-uri/3.0.7: resolution: {integrity: sha512-8cXDaBBHOr2pQ7j77Y6Vp5VDT2sIqWyWQ56TjEq4ih/a4iST3dItRe8Q9fp0rrIl9DoKhWQtUQz/YpOxLkXbNA==} engines: {node: '>=6.0.0'} - dev: false /@jridgewell/set-array/1.1.1: resolution: {integrity: sha512-Ct5MqZkLGEXTVmQYbGtx9SVqD2fqwvdubdps5D3djjAkgkKwT918VNOz65pEHFaYTeWcukmJmH5SwsA9Tn2ObQ==} engines: {node: '>=6.0.0'} - dev: false /@jridgewell/sourcemap-codec/1.4.13: resolution: {integrity: sha512-GryiOJmNcWbovBxTfZSF71V/mXbgcV3MewDe3kIMCLyIh5e7SKAeUZs+rMnJ8jkMolZ/4/VsdBmMrw3l+VdZ3w==} - dev: false /@jridgewell/trace-mapping/0.3.13: resolution: {integrity: sha512-o1xbKhp9qnIAoHJSWd6KlCZfqslL4valSF81H8ImioOAxluWYWOpWkpyktY2vnt4tbrX9XYaxovq6cgowaJp2w==} dependencies: '@jridgewell/resolve-uri': 3.0.7 '@jridgewell/sourcemap-codec': 1.4.13 - dev: false /@lifeomic/attempt/3.0.2: resolution: {integrity: sha512-JHRfM7fUit2UroC0xRnuzMGegSTbfvz6X/1PgcIvahXC+A7UsKa8XfR1YrBsvoSu669iMTeNkDb26pSkGOzXKw==} @@ -2543,12 +2445,10 @@ packages: dependencies: '@nodelib/fs.stat': 2.0.5 run-parallel: 1.2.0 - dev: true /@nodelib/fs.stat/2.0.5: resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} engines: {node: '>= 8'} - dev: true /@nodelib/fs.walk/1.2.8: resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} @@ -2556,7 +2456,6 @@ packages: dependencies: '@nodelib/fs.scandir': 2.1.5 fastq: 1.13.0 - dev: true /@nuxtjs/opencollective/0.3.2: resolution: {integrity: sha512-um0xL3fO7Mf4fDxcqx9KryrB7zgRM5JSlvGN5AGkP6JLM5XEKyjeAiPbNxdXVXQ16isuAhYpvP88NgL2BGd6aA==} @@ -2574,31 +2473,46 @@ packages: resolution: {integrity: sha512-92FRmppjjqz29VMJ2dn+xdyXZBrMlE42AV6Kq6BwjWV7CNUW1hs2FtxSNLQE+gJhaZ6AAmYuO9y8dshhcBl7vA==} dev: false - /@rollup/plugin-node-resolve/7.1.3_rollup@1.32.1: - resolution: {integrity: sha512-RxtSL3XmdTAE2byxekYLnx+98kEUOrPHF/KRVjLH+DEIHy6kjIw7YINQzn+NXiH/NTrQLAwYs0GWB+csWygA9Q==} - engines: {node: '>= 8.0.0'} + /@rollup/plugin-babel/5.3.1_04044e04815e91b52200805e849584d4: + resolution: {integrity: sha512-WFfdLWU/xVWKeRQnKmIAQULUI7Il0gZnBIH/ZFO069wYIfPu+8zrfp/KMW0atmELoRDq8FbiP3VCss9MhCut7Q==} + engines: {node: '>= 10.0.0'} + peerDependencies: + '@babel/core': ^7.0.0 + '@types/babel__core': ^7.1.9 + rollup: ^1.20.0||^2.0.0 + peerDependenciesMeta: + '@types/babel__core': + optional: true + dependencies: + '@babel/core': 7.16.12 + '@babel/helper-module-imports': 7.16.7 + '@rollup/pluginutils': 3.1.0_rollup@2.74.1 + rollup: 2.74.1 + + /@rollup/plugin-node-resolve/11.2.1_rollup@2.74.1: + resolution: {integrity: sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==} + engines: {node: '>= 10.0.0'} peerDependencies: rollup: ^1.20.0||^2.0.0 dependencies: - '@rollup/pluginutils': 3.1.0_rollup@1.32.1 - '@types/resolve': 0.0.8 + '@rollup/pluginutils': 3.1.0_rollup@2.74.1 + '@types/resolve': 1.17.1 builtin-modules: 3.3.0 + deepmerge: 4.2.2 is-module: 1.0.0 resolve: 1.22.0 - rollup: 1.32.1 - dev: false + rollup: 2.74.1 - /@rollup/plugin-replace/2.4.2_rollup@1.32.1: + /@rollup/plugin-replace/2.4.2_rollup@2.74.1: resolution: {integrity: sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==} peerDependencies: rollup: ^1.20.0 || ^2.0.0 dependencies: - '@rollup/pluginutils': 3.1.0_rollup@1.32.1 + '@rollup/pluginutils': 3.1.0_rollup@2.74.1 magic-string: 0.25.7 - rollup: 1.32.1 - dev: false + rollup: 2.74.1 - /@rollup/pluginutils/3.1.0_rollup@1.32.1: + /@rollup/pluginutils/3.1.0_rollup@2.74.1: resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==} engines: {node: '>= 8.0.0'} peerDependencies: @@ -2607,8 +2521,7 @@ packages: '@types/estree': 0.0.39 estree-walker: 1.0.1 picomatch: 2.3.1 - rollup: 1.32.1 - dev: false + rollup: 2.74.1 /@sinonjs/commons/1.8.3: resolution: {integrity: sha512-xkNcLAn/wZaX14RPlwizcKicDk9G3F8m2nU3L7Ukm5zBgTwiT0wsoFAHx9Jq56fJA1z/7uKGtCRu16sOUCLIHQ==} @@ -2626,12 +2539,13 @@ packages: resolution: {integrity: sha512-O3uyB/JbkAEMZaP3YqyHH7TMnex7tWyCbCI4EfJdOCoN6HIhqdJBWTM6aCCiWQ/5f5wxjgU735QAIpJbjDvmzg==} dev: false - /@surma/rollup-plugin-off-main-thread/1.4.2: - resolution: {integrity: sha512-yBMPqmd1yEJo/280PAMkychuaALyQ9Lkb5q1ck3mjJrFuEobIfhnQ4J3mbvBoISmR3SWMWV+cGB/I0lCQee79A==} + /@surma/rollup-plugin-off-main-thread/2.2.3: + resolution: {integrity: sha512-lR8q/9W7hZpMWweNiAKU7NQerBnzQQLvi8qnTDU/fxItPhtZVMbPV3lbCwjhIlNBe9Bbr5V+KHshvWmVSG9cxQ==} dependencies: - ejs: 2.7.4 + ejs: 3.1.8 + json5: 2.2.0 magic-string: 0.25.7 - dev: false + string.prototype.matchall: 4.0.7 /@tiptap/core/2.0.0-beta.171: resolution: {integrity: sha512-4CdJfcchmBOFooWPBMJ7AxJISeTstMFriQv0RyReMt0Dpef/c9UoU+NkKLwwv5VRUX0M8dL5SzEhkB8wIODqlA==} @@ -3092,10 +3006,10 @@ packages: /@types/estree/0.0.39: resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==} - dev: false /@types/estree/0.0.50: resolution: {integrity: sha512-C6N5s2ZFtuZRj54k2/zyRhNDjJwwcViAM3Nbm8zjBpbqAdZ00mr0CFxvSKeO8Y/e03WVFLpQMdHYVfUd6SB+Hw==} + dev: true /@types/express-serve-static-core/4.17.28: resolution: {integrity: sha512-P1BJAEAW3E2DJUlkgq4tOL3RyMunoWXqbSCygWo5ZIWTjUgN1YnaXWW4VWl/oc8vs/XoYibEGBKP0uZyF4AHig==} @@ -3114,6 +3028,13 @@ packages: '@types/serve-static': 1.13.10 dev: true + /@types/glob/7.2.0: + resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==} + dependencies: + '@types/minimatch': 3.0.5 + '@types/node': 17.0.35 + dev: false + /@types/graceful-fs/4.1.5: resolution: {integrity: sha512-anKkLmZZ+xm4p8JWBf4hElkM4XR+EZeA2M9BAkkTldmcyDY4mbdIJnRghDJH3Ov5ooY7/UAoENtmdMSkaAd7Cw==} dependencies: @@ -3170,6 +3091,10 @@ packages: resolution: {integrity: sha512-YATxVxgRqNH6nHEIsvg6k2Boc1JHI9ZbH5iWFFv/MTkchz3b1ieGDa5T0a9RznNdI0KhVbdbWSN+KWWrQZRxTw==} dev: true + /@types/minimatch/3.0.5: + resolution: {integrity: sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==} + dev: false + /@types/minimist/1.2.2: resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==} dev: true @@ -3180,6 +3105,9 @@ packages: /@types/node/17.0.13: resolution: {integrity: sha512-Y86MAxASe25hNzlDbsviXl8jQHb0RDvKt4c40ZJQ1Don0AAL0STLZSs4N+6gLEO55pedy7r2cLwS+ZDxPm/2Bw==} + /@types/node/17.0.35: + resolution: {integrity: sha512-vu1SrqBjbbZ3J6vwY17jBs8Sr/BKA+/a/WtjRG+whKg1iuLFOosq872EXS0eXWILdO36DHQQeku/ZcL6hz2fpg==} + /@types/normalize-package-data/2.4.1: resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==} dev: true @@ -3293,11 +3221,10 @@ packages: '@types/scheduler': 0.16.2 csstype: 3.0.10 - /@types/resolve/0.0.8: - resolution: {integrity: sha512-auApPaJf3NPfe18hSoJkp8EbZzer2ISk7o8mCC3M9he/a04+gbMF97NkpD2S8riMGvm4BMRI59/SZQSaLTKpsQ==} + /@types/resolve/1.17.1: + resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==} dependencies: - '@types/node': 17.0.13 - dev: false + '@types/node': 17.0.35 /@types/scheduler/0.16.2: resolution: {integrity: sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==} @@ -3326,6 +3253,9 @@ packages: '@types/superagent': 4.1.15 dev: true + /@types/trusted-types/2.0.2: + resolution: {integrity: sha512-F5DIZ36YVLE+PN+Zwws4kJogq47hNgX3Nx6WyDJ3kcplxyke3XIzB8uK5n/Lpm1HBsbGzd6nmGehL8cPekP+Tg==} + /@types/unist/2.0.6: resolution: {integrity: sha512-PBjIUxZHOuj0R15/xuwJYjFi+KZdNFrehocChv4g5hu6aFroHue8m0lBP0POdK2nKzbw0cgV1mws8+V/JAcEkQ==} dev: false @@ -3643,6 +3573,7 @@ packages: resolution: {integrity: sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==} engines: {node: '>=0.4.0'} hasBin: true + dev: true /acorn/8.7.0: resolution: {integrity: sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ==} @@ -3678,21 +3609,13 @@ packages: indent-string: 4.0.0 dev: true - /ajv-errors/1.0.1_ajv@6.12.6: - resolution: {integrity: sha512-DCRfO/4nQ+89p/RK43i8Ezd41EqdGIU4ld7nGF8OQ14oc/we5rEntLCUa7+jrn3nn83BosfwZA0wb4pon2o8iQ==} - peerDependencies: - ajv: '>=5.0.0' - dependencies: - ajv: 6.12.6 - dev: false - /ajv-formats/2.1.1: resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==} peerDependenciesMeta: ajv: optional: true dependencies: - ajv: 8.6.3 + ajv: 8.8.2 dev: true /ajv-keywords/3.5.2_ajv@6.12.6: @@ -3702,6 +3625,15 @@ packages: dependencies: ajv: 6.12.6 + /ajv-keywords/5.1.0_ajv@8.8.2: + resolution: {integrity: sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==} + peerDependencies: + ajv: ^8.8.2 + dependencies: + ajv: 8.8.2 + fast-deep-equal: 3.1.3 + dev: true + /ajv/6.12.6: resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} dependencies: @@ -3726,7 +3658,6 @@ packages: json-schema-traverse: 1.0.0 require-from-string: 2.0.2 uri-js: 4.4.1 - dev: true /ali-oss/6.16.0: resolution: {integrity: sha512-tK/+yEKtBBD+kMoHABxg6lCgC+Ad9HNjCln7qdL6LRYbUm+FFTKJubC4hT2FIooMBDb9tnI7My4MVreKnbJQRg==} @@ -3762,11 +3693,6 @@ packages: - supports-color dev: false - /ansi-colors/3.2.4: - resolution: {integrity: sha512-hHUXGagefjN2iRrID63xckIvotOXOojhQKWIPUZ4mNUZ9nLZW+7FMNoE1lOkEhNWYsx/7ysGIuJYCiMAA9FnrA==} - engines: {node: '>=6'} - dev: false - /ansi-colors/4.1.1: resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==} engines: {node: '>=6'} @@ -3830,10 +3756,6 @@ packages: resolution: {integrity: sha1-HjRA6RXwsSA9I3SOeO3XubW0PlY=} dev: false - /aproba/1.2.0: - resolution: {integrity: sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==} - dev: false - /arg/4.1.3: resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} dev: true @@ -3872,7 +3794,6 @@ packages: /array-union/2.1.0: resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} engines: {node: '>=8'} - dev: true /array-uniq/1.0.3: resolution: {integrity: sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==} @@ -3928,6 +3849,9 @@ packages: resolution: {integrity: sha512-8eLCg00W9pIRZSB781UUX/H6Oskmm8xloZfr09lz5bikRpBVDlJ3hRVuxxP1SxcwsEYfJ4IU8Q19Y8/893r3rQ==} dev: false + /async/3.2.3: + resolution: {integrity: sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g==} + /asynckit/0.4.0: resolution: {integrity: sha1-x57Zf380y48robyXkLzDZkdLS3k=} dev: true @@ -3935,7 +3859,6 @@ packages: /at-least-node/1.0.0: resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} engines: {node: '>= 4.0.0'} - dev: true /available-typed-arrays/1.0.5: resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==} @@ -3958,13 +3881,6 @@ packages: - debug dev: false - /babel-extract-comments/1.0.0: - resolution: {integrity: sha512-qWWzi4TlddohA91bFwgt6zO/J0X+io7Qp184Fw0m2JYRSTZnJbFR8+07KmzudHCZgOiKRCrjhylwv9Xd8gfhVQ==} - engines: {node: '>=4'} - dependencies: - babylon: 6.18.0 - dev: false - /babel-jest/27.4.6_@babel+core@7.16.12: resolution: {integrity: sha512-qZL0JT0HS1L+lOuH+xC2DVASR3nunZi/ozGhpgauJHgmI7f8rudxf6hUjEHympdQ/J64CdKmPkgfJ+A3U6QCrg==} engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} @@ -3984,11 +3900,23 @@ packages: - supports-color dev: true + /babel-loader/8.2.5: + resolution: {integrity: sha512-OSiFfH89LrEMiWd4pLNqGz4CwJDtbs2ZVc+iGu2HrkRfPxId9F2anQj38IxWpmRfsUY0aBZYi1EFcd3mhtRMLQ==} + engines: {node: '>= 8.9'} + peerDependencies: + '@babel/core': ^7.0.0 + webpack: '>=2' + dependencies: + find-cache-dir: 3.3.2 + loader-utils: 2.0.0 + make-dir: 3.1.0 + schema-utils: 2.7.1 + dev: false + /babel-plugin-dynamic-import-node/2.3.3: resolution: {integrity: sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==} dependencies: object.assign: 4.1.2 - dev: false /babel-plugin-istanbul/6.1.1: resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==} @@ -4024,7 +3952,6 @@ packages: semver: 6.3.0 transitivePeerDependencies: - supports-color - dev: false /babel-plugin-polyfill-corejs3/0.5.2_@babel+core@7.16.12: resolution: {integrity: sha512-G3uJih0XWiID451fpeFaYGVuxHEjzKTHtc9uGFEjR6hHrvNzeS/PX+LLLcetJcytsB5m4j+K3o/EpXJNb/5IEQ==} @@ -4036,7 +3963,6 @@ packages: core-js-compat: 3.22.5 transitivePeerDependencies: - supports-color - dev: false /babel-plugin-polyfill-regenerator/0.3.1_@babel+core@7.16.12: resolution: {integrity: sha512-Y2B06tvgHYt1x0yz17jGkGeeMr5FeKUu+ASJ+N6nB5lQ8Dapfg42i0OVrf8PNGJ3zKL4A23snMi1IRwrqqND7A==} @@ -4047,18 +3973,6 @@ packages: '@babel/helper-define-polyfill-provider': 0.3.1_@babel+core@7.16.12 transitivePeerDependencies: - supports-color - dev: false - - /babel-plugin-syntax-object-rest-spread/6.13.0: - resolution: {integrity: sha512-C4Aq+GaAj83pRQ0EFgTvw5YO6T3Qz2KGrNRwIj9mSoNHVvdZY4KO2uA6HNtNXCw993iSZnckY1aLW8nOi8i4+w==} - dev: false - - /babel-plugin-transform-object-rest-spread/6.26.0: - resolution: {integrity: sha512-ocgA9VJvyxwt+qJB0ncxV8kb/CjfTcECUY4tQ5VT7nP6Aohzobm8CDFaQ5FHdvZQzLmf0sgDxB8iRXZXxwZcyA==} - dependencies: - babel-plugin-syntax-object-rest-spread: 6.13.0 - babel-runtime: 6.26.0 - dev: false /babel-preset-current-node-syntax/1.0.1_@babel+core@7.16.12: resolution: {integrity: sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==} @@ -4091,18 +4005,6 @@ packages: babel-preset-current-node-syntax: 1.0.1_@babel+core@7.16.12 dev: true - /babel-runtime/6.26.0: - resolution: {integrity: sha512-ITKNuq2wKlW1fJg9sSW52eepoYgZBggvOAHC0u/CYu/qxQ9EVzThCgR69BnSXLHjy2f7SY5zaQ4yt7H9ZVxY2g==} - dependencies: - core-js: 2.6.12 - regenerator-runtime: 0.11.1 - dev: false - - /babylon/6.18.0: - resolution: {integrity: sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==} - hasBin: true - dev: false - /balanced-match/1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} @@ -4137,10 +4039,6 @@ packages: readable-stream: 3.6.0 dev: true - /bluebird/3.7.2: - resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==} - dev: false - /body-parser/1.19.1: resolution: {integrity: sha512-8ljfQi5eBk8EJfECMrgqNGWPEY5jWP+1IzkzkGdFFEwFQZZyaZ21UqdaHktgiMlH0xLHqIFtE/u2OYE5dOtViA==} engines: {node: '>= 0.8'} @@ -4167,6 +4065,11 @@ packages: balanced-match: 1.0.2 concat-map: 0.0.1 + /brace-expansion/2.0.1: + resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} + dependencies: + balanced-match: 1.0.2 + /braces/3.0.2: resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} engines: {node: '>=8'} @@ -4198,7 +4101,6 @@ packages: escalade: 3.1.1 node-releases: 2.0.4 picocolors: 1.0.0 - dev: false /bs-logger/0.2.6: resolution: {integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==} @@ -4237,7 +4139,6 @@ packages: /builtin-modules/3.3.0: resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} engines: {node: '>=6'} - dev: false /builtin-status-codes/3.0.0: resolution: {integrity: sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=} @@ -4256,26 +4157,6 @@ packages: engines: {node: '>= 0.8'} dev: false - /cacache/12.0.4: - resolution: {integrity: sha512-a0tMB40oefvuInr4Cwb3GerbL9xTj1D5yg0T5xrjGCGyfvbxseIXX7BAO/u/hIXdafzOI5JC3wDwHyf24buOAQ==} - dependencies: - bluebird: 3.7.2 - chownr: 1.1.4 - figgy-pudding: 3.5.2 - glob: 7.2.0 - graceful-fs: 4.2.9 - infer-owner: 1.0.4 - lru-cache: 5.1.1 - mississippi: 3.0.0 - mkdirp: 0.5.5 - move-concurrently: 1.0.1 - promise-inflight: 1.0.1 - rimraf: 2.7.1 - ssri: 6.0.2 - unique-filename: 1.1.1 - y18n: 4.0.3 - dev: false - /call-bind/1.0.2: resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==} dependencies: @@ -4310,7 +4191,6 @@ packages: /caniuse-lite/1.0.30001341: resolution: {integrity: sha512-2SodVrFFtvGENGCv0ChVJIDQ0KPaS1cg7/qtfMaICgeMolDdo/Z2OD32F0Aq9yl6F4YFwGPBS5AaPqNYiW4PoA==} - dev: false /chalk/2.4.2: resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} @@ -4358,10 +4238,6 @@ packages: optionalDependencies: fsevents: 2.3.2 - /chownr/1.1.4: - resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} - dev: false - /chrome-trace-event/1.0.3: resolution: {integrity: sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==} engines: {node: '>=6.0'} @@ -4395,6 +4271,15 @@ packages: engines: {node: '>=6'} dev: true + /clean-webpack-plugin/4.0.0: + resolution: {integrity: sha512-WuWE1nyTNAyW5T7oNyys2EN0cfP2fdRxhxnIQWiAp0bMabPdHhoGxM8A6YL2GhqwgrPnnaemVE7nv5XJ2Fhh2w==} + engines: {node: '>=10.0.0'} + peerDependencies: + webpack: '>=4.0.0 <6.0.0' + dependencies: + del: 4.1.1 + dev: false + /cli-cursor/3.1.0: resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} engines: {node: '>=8'} @@ -4554,7 +4439,6 @@ packages: /common-tags/1.8.2: resolution: {integrity: sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==} engines: {node: '>=4.0.0'} - dev: false /commondir/1.0.1: resolution: {integrity: sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=} @@ -4630,17 +4514,6 @@ packages: resolution: {integrity: sha512-JxbCBUdrfr6AQjOXrxoTvAMJO4HBTUIlBzslcJPAz+/KT8yk53fXun51u+RenNYvad/+Vc2DIz5o9UxlCDymFQ==} dev: true - /copy-concurrently/1.0.5: - resolution: {integrity: sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==} - dependencies: - aproba: 1.2.0 - fs-write-stream-atomic: 1.0.10 - iferr: 0.1.5 - mkdirp: 0.5.5 - rimraf: 2.7.1 - run-queue: 1.0.3 - dev: false - /copy-text-to-clipboard/2.2.0: resolution: {integrity: sha512-WRvoIdnTs1rgPMkgA2pUOa/M4Enh2uzCwdKsOMYNAJiz/4ZvEJgmbF4OmninPmlFdAWisfeh0tH+Cpf7ni3RqQ==} engines: {node: '>=6'} @@ -4650,44 +4523,31 @@ packages: resolution: {integrity: sha1-JoD7uAaKSNCGVrYJgJK9r8kG9KU=} dev: false - /copy-webpack-plugin/5.1.2: - resolution: {integrity: sha512-Uh7crJAco3AjBvgAy9Z75CjK8IG+gxaErro71THQ+vv/bl4HaQcpkexAY8KVW/T6D2W2IRr+couF/knIRkZMIQ==} - engines: {node: '>= 6.9.0'} + /copy-webpack-plugin/11.0.0: + resolution: {integrity: sha512-fX2MWpamkW0hZxMEg0+mYnA40LTosOSa5TqZ9GYIBzyJa9C3QUaMPSE2xAi/buNr8u89SfD9wHSQVBzrRa/SOQ==} + engines: {node: '>= 14.15.0'} peerDependencies: - webpack: ^4.0.0 || ^5.0.0 + webpack: ^5.1.0 dependencies: - cacache: 12.0.4 - find-cache-dir: 2.1.0 - glob-parent: 3.1.0 - globby: 7.1.1 - is-glob: 4.0.3 - loader-utils: 1.4.0 - minimatch: 3.1.2 + fast-glob: 3.2.11 + glob-parent: 6.0.2 + globby: 13.1.1 normalize-path: 3.0.0 - p-limit: 2.3.0 - schema-utils: 1.0.0 - serialize-javascript: 4.0.0 - webpack-log: 2.0.0 - dev: false + schema-utils: 4.0.0 + serialize-javascript: 6.0.0 + dev: true /core-js-compat/3.22.5: resolution: {integrity: sha512-rEF75n3QtInrYICvJjrAgV03HwKiYvtKHdPtaba1KucG+cNZ4NJnH9isqt979e67KZlhpbCOTwnsvnIr+CVeOg==} dependencies: browserslist: 4.20.3 semver: 7.0.0 - dev: false /core-js-pure/3.20.3: resolution: {integrity: sha512-Q2H6tQ5MtPtcC7f3HxJ48i4Q7T9ybPKgvWyuH7JXIoNa2pm0KuBnycsET/qw1SLLZYfbsbrZQNMeIOClb+6WIA==} requiresBuild: true dev: false - /core-js/2.6.12: - resolution: {integrity: sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==} - deprecated: core-js@<3.4 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Please, upgrade your dependencies to the actual version of core-js. - requiresBuild: true - dev: false - /core-util-is/1.0.3: resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} dev: false @@ -4742,10 +4602,9 @@ packages: shebang-command: 2.0.0 which: 2.0.2 - /crypto-random-string/1.0.0: - resolution: {integrity: sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=} - engines: {node: '>=4'} - dev: false + /crypto-random-string/2.0.0: + resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==} + engines: {node: '>=8'} /css-functions-list/3.0.1: resolution: {integrity: sha512-PriDuifDt4u4rkDgnqRCLnjfMatufLmWNfQnGCq34xZwpY3oabwhB9SqRBmuvWUgndbemCFlKqg+nO7C2q0SBw==} @@ -4795,10 +4654,6 @@ packages: /csstype/3.0.10: resolution: {integrity: sha512-2u44ZG2OcNUO9HDp/Jl8C07x6pU/eTR3ncV91SiK3dhG9TWvRVsCoJw14Ckx5DgWkzGA3waZWO3d7pgqpUI/XA==} - /cyclist/1.0.1: - resolution: {integrity: sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=} - dev: false - /data-uri-to-buffer/3.0.1: resolution: {integrity: sha512-WboRycPNsVw3B3TL559F7kuBUM4d8CgMEvk6xEJlOp7OBPjt6G7z8WMWlD2rOFZLk6OYfFIUGsCOWzcQH9K2og==} engines: {node: '>= 6'} @@ -4923,7 +4778,6 @@ packages: /deepmerge/4.2.2: resolution: {integrity: sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==} engines: {node: '>=0.10.0'} - dev: true /default-user-agent/1.0.0: resolution: {integrity: sha1-FsRu/cq6PtxF8k8r1IaLAbfCrcY=} @@ -4954,6 +4808,19 @@ packages: vm2: 3.9.5 dev: false + /del/4.1.1: + resolution: {integrity: sha512-QwGuEUouP2kVwQenAsOof5Fv8K9t3D8Ca8NxcXKrIpEHjTXK5J2nXLdP+ALI1cgv8wj7KuwBhTwBkOZSJKM5XQ==} + engines: {node: '>=6'} + dependencies: + '@types/glob': 7.2.0 + globby: 6.1.0 + is-path-cwd: 2.2.0 + is-path-in-cwd: 2.1.0 + p-map: 2.1.0 + pify: 4.0.1 + rimraf: 2.7.1 + dev: false + /delayed-stream/1.0.0: resolution: {integrity: sha1-3zrhmayt+31ECqrgsp4icrJOxhk=} engines: {node: '>=0.4.0'} @@ -5010,19 +4877,11 @@ packages: utility: 0.1.11 dev: false - /dir-glob/2.2.2: - resolution: {integrity: sha512-f9LBi5QWzIW3I6e//uxZoLBlUt9kcp66qo0sSCxL6YZKc75R1c4MFCoe/LaZiBGmgujvQdxc5Bn3QhfyvK5Hsw==} - engines: {node: '>=4'} - dependencies: - path-type: 3.0.0 - dev: false - /dir-glob/3.0.1: resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} engines: {node: '>=8'} dependencies: path-type: 4.0.0 - dev: true /doctrine/2.1.0: resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} @@ -5063,15 +4922,6 @@ packages: engines: {node: '>=10'} dev: false - /duplexify/3.7.1: - resolution: {integrity: sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==} - dependencies: - end-of-stream: 1.4.4 - inherits: 2.0.4 - readable-stream: 2.3.7 - stream-shift: 1.0.1 - dev: false - /eastasianwidth/0.2.0: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} dev: true @@ -5086,15 +4936,15 @@ packages: resolution: {integrity: sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=} dev: false - /ejs/2.7.4: - resolution: {integrity: sha512-7vmuyh5+kuUyJKePhQfRQBhXV5Ce+RnaeeQArKu1EAMpL3WbgMt5WG6uQZpEVvYSSsxMXRKOewtDk9RaTKXRlA==} + /ejs/3.1.8: + resolution: {integrity: sha512-/sXZeMlhS0ArkfX2Aw780gJzXSMPnKjtspYZv+f3NiKLlubezAHDU5+9xz6gd3/NhG3txQCo6xlglmTS+oTGEQ==} engines: {node: '>=0.10.0'} - requiresBuild: true - dev: false + hasBin: true + dependencies: + jake: 10.8.5 /electron-to-chromium/1.4.137: resolution: {integrity: sha512-0Rcpald12O11BUogJagX3HsCN3FE83DSqWjgXoHo5a72KUKMSfI39XBgJpgNNxS9fuGzytaFjE06kZkiVFy2qA==} - dev: false /electron-to-chromium/1.4.57: resolution: {integrity: sha512-FNC+P5K1n6pF+M0zIK+gFCoXcJhhzDViL3DRIGy2Fv5PohuSES1JHR7T+GlwxSxlzx4yYbsuzCZvHxcBSRCIOw==} @@ -5341,6 +5191,22 @@ packages: prettier-linter-helpers: 1.0.0 dev: true + /eslint-plugin-prettier/4.0.0_74ebb802163a9b4fa8f89d76ed02f62a: + resolution: {integrity: sha512-98MqmCJ7vJodoQK359bqQWaxOE0CS8paAz/GgjaZLyex4TTk3g9HugoO89EqWCrFiOqn9EVvcoo7gZzONCWVwQ==} + engines: {node: '>=6.0.0'} + peerDependencies: + eslint: '>=7.28.0' + eslint-config-prettier: '*' + prettier: '>=2.0.0' + peerDependenciesMeta: + eslint-config-prettier: + optional: true + dependencies: + eslint: 8.14.0 + eslint-config-prettier: 8.5.0_eslint@8.14.0 + prettier-linter-helpers: 1.0.0 + dev: true + /eslint-plugin-react-hooks/4.5.0_eslint@8.14.0: resolution: {integrity: sha512-8k1gRt7D7h03kd+SAAlzXkQwWK22BnK6GKZG+FJA6BAGy22CFvl8kCIXKpVux0cCxMWDQUPqSok0LKaZ0aOcCw==} engines: {node: '>=10'} @@ -5498,13 +5364,8 @@ packages: engines: {node: '>=4.0'} dev: true - /estree-walker/0.6.1: - resolution: {integrity: sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==} - dev: false - /estree-walker/1.0.1: resolution: {integrity: sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==} - dev: false /esutils/2.0.3: resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} @@ -5649,7 +5510,6 @@ packages: glob-parent: 5.1.2 merge2: 1.4.1 micromatch: 4.0.4 - dev: true /fast-json-stable-stringify/2.1.0: resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} @@ -5668,7 +5528,6 @@ packages: resolution: {integrity: sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==} dependencies: reusify: 1.0.4 - dev: true /fault/1.0.4: resolution: {integrity: sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==} @@ -5688,10 +5547,6 @@ packages: bser: 2.1.1 dev: true - /figgy-pudding/3.5.2: - resolution: {integrity: sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw==} - dev: false - /figures/3.2.0: resolution: {integrity: sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==} engines: {node: '>=8'} @@ -5721,6 +5576,11 @@ packages: engines: {node: '>= 6'} dev: false + /filelist/1.0.4: + resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==} + dependencies: + minimatch: 5.1.0 + /fill-range/7.0.1: resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} engines: {node: '>=8'} @@ -5740,13 +5600,13 @@ packages: unpipe: 1.0.0 dev: false - /find-cache-dir/2.1.0: - resolution: {integrity: sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==} - engines: {node: '>=6'} + /find-cache-dir/3.3.2: + resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==} + engines: {node: '>=8'} dependencies: commondir: 1.0.1 - make-dir: 2.1.0 - pkg-dir: 3.0.0 + make-dir: 3.1.0 + pkg-dir: 4.2.0 dev: false /find-up/2.1.0: @@ -5756,20 +5616,12 @@ packages: locate-path: 2.0.0 dev: true - /find-up/3.0.0: - resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==} - engines: {node: '>=6'} - dependencies: - locate-path: 3.0.0 - dev: false - /find-up/4.1.0: resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} dependencies: locate-path: 5.0.0 path-exists: 4.0.0 - dev: true /flat-cache/3.0.4: resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==} @@ -5783,13 +5635,6 @@ packages: resolution: {integrity: sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==} dev: true - /flush-write-stream/1.1.1: - resolution: {integrity: sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==} - dependencies: - inherits: 2.0.4 - readable-stream: 2.3.7 - dev: false - /follow-redirects/1.14.7: resolution: {integrity: sha512-+hbxoLbFMbRKDwohX8GkTataGqO6Jb7jGwpAlwgy2bIz25XtRm7KEzJM76R1WiNT5SwZkX4Y75SwBolkpmE7iQ==} engines: {node: '>=4.0'} @@ -5886,13 +5731,6 @@ packages: engines: {node: '>= 0.6'} dev: false - /from2/2.3.0: - resolution: {integrity: sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=} - dependencies: - inherits: 2.0.4 - readable-stream: 2.3.7 - dev: false - /fs-extra/10.0.0: resolution: {integrity: sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==} engines: {node: '>=12'} @@ -5918,21 +5756,11 @@ packages: graceful-fs: 4.2.9 jsonfile: 6.1.0 universalify: 2.0.0 - dev: true /fs-monkey/1.0.3: resolution: {integrity: sha512-cybjIfiiE+pTWicSCLFHSrXZ6EilF30oh91FDP9S2B051prEa7QWfrVTQm10/dDpswBDXZugPa1Ogu8Yh+HV0Q==} dev: true - /fs-write-stream-atomic/1.0.10: - resolution: {integrity: sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=} - dependencies: - graceful-fs: 4.2.9 - iferr: 0.1.5 - imurmurhash: 0.1.4 - readable-stream: 2.3.7 - dev: false - /fs.realpath/1.0.0: resolution: {integrity: sha1-FQStJSMVjKpA20onh8sBQRmU6k8=} @@ -5981,7 +5809,6 @@ packages: /get-own-enumerable-property-symbols/3.0.2: resolution: {integrity: sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==} - dev: false /get-package-type/0.1.0: resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} @@ -6030,13 +5857,6 @@ packages: - supports-color dev: false - /glob-parent/3.1.0: - resolution: {integrity: sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=} - dependencies: - is-glob: 3.1.0 - path-dirname: 1.0.2 - dev: false - /glob-parent/5.1.2: resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} engines: {node: '>= 6'} @@ -6101,18 +5921,27 @@ packages: ignore: 5.2.0 merge2: 1.4.1 slash: 3.0.0 + + /globby/13.1.1: + resolution: {integrity: sha512-XMzoDZbGZ37tufiv7g0N4F/zp3zkwdFtVbV3EHsVl1KQr4RPLfNoT068/97RPshz2J5xYNEjLKKBKaGHifBd3Q==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dependencies: + dir-glob: 3.0.1 + fast-glob: 3.2.11 + ignore: 5.2.0 + merge2: 1.4.1 + slash: 4.0.0 dev: true - /globby/7.1.1: - resolution: {integrity: sha1-+yzP+UAfhgCUXfral0QMypcrhoA=} - engines: {node: '>=4'} + /globby/6.1.0: + resolution: {integrity: sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=} + engines: {node: '>=0.10.0'} dependencies: array-union: 1.0.2 - dir-glob: 2.2.2 glob: 7.2.0 - ignore: 3.3.10 - pify: 3.0.0 - slash: 1.0.0 + object-assign: 4.1.1 + pify: 2.3.0 + pinkie-promise: 2.0.1 dev: false /globjoin/0.1.4: @@ -6276,21 +6105,15 @@ packages: postcss: 7.0.39 dev: false + /idb/6.1.5: + resolution: {integrity: sha512-IJtugpKkiVXQn5Y+LteyBCNk1N8xpGV3wWZk9EVtZWH8DYkjBn0bX1XnGP9RkyZF0sAcywa6unHqSWKe7q4LGw==} + /ieee754/1.2.1: resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} - /iferr/0.1.5: - resolution: {integrity: sha1-xg7taebY/bazEEofy8ocGS3FtQE=} - dev: false - - /ignore/3.3.10: - resolution: {integrity: sha512-Pgs951kaMm5GXP7MOvxERINe3gsaVjUWFm+UZPSq9xYriQAksyhg0csnS0KXSNRD5NmNdapXEpjxG49+AKh/ug==} - dev: false - /ignore/5.2.0: resolution: {integrity: sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==} engines: {node: '>= 4'} - dev: true /import-fresh/3.3.0: resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} @@ -6317,16 +6140,13 @@ packages: /imurmurhash/0.1.4: resolution: {integrity: sha1-khi5srkoojixPcT7a21XbyMUU+o=} engines: {node: '>=0.8.19'} + dev: true /indent-string/4.0.0: resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} engines: {node: '>=8'} dev: true - /infer-owner/1.0.4: - resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==} - dev: false - /inflight/1.0.6: resolution: {integrity: sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=} dependencies: @@ -6502,13 +6322,6 @@ packages: engines: {node: '>=6'} dev: true - /is-glob/3.1.0: - resolution: {integrity: sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=} - engines: {node: '>=0.10.0'} - dependencies: - is-extglob: 2.1.1 - dev: false - /is-glob/4.0.3: resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} engines: {node: '>=0.10.0'} @@ -6526,7 +6339,6 @@ packages: /is-module/1.0.0: resolution: {integrity: sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=} - dev: false /is-negative-zero/2.0.2: resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==} @@ -6545,6 +6357,24 @@ packages: /is-obj/1.0.1: resolution: {integrity: sha1-PkcprB9f3gJc19g6iW2rn09n2w8=} engines: {node: '>=0.10.0'} + + /is-path-cwd/2.2.0: + resolution: {integrity: sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==} + engines: {node: '>=6'} + dev: false + + /is-path-in-cwd/2.1.0: + resolution: {integrity: sha512-rNocXHgipO+rvnP6dk3zI20RpOtrAM/kzbB258Uw5BWr3TpXi861yzjo16Dn4hUox07iw5AyeMLHWsujkjzvRQ==} + engines: {node: '>=6'} + dependencies: + is-path-inside: 2.1.0 + dev: false + + /is-path-inside/2.1.0: + resolution: {integrity: sha512-wiyhTzfDWsvwAW53OBWF5zuvaOGlZ6PwYxAbPVDhpm+gM09xKQGjBq/8uYN12aDvMxnAnq3dxTyoSoRNmg5YFg==} + engines: {node: '>=6'} + dependencies: + path-is-inside: 1.0.2 dev: false /is-plain-obj/1.1.0: @@ -6575,7 +6405,6 @@ packages: /is-regexp/1.0.0: resolution: {integrity: sha1-/S2INUXEa6xaYz57mgnof6LLUGk=} engines: {node: '>=0.10.0'} - dev: false /is-regexp/2.1.0: resolution: {integrity: sha512-OZ4IlER3zmRIoB9AqNhEggVxqIH4ofDns5nRrPS6yQxXE1TPCUpFznBfRQmQa8uC+pXqjMnukiJBxCisIxiLGA==} @@ -6598,7 +6427,6 @@ packages: /is-stream/2.0.1: resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} engines: {node: '>=8'} - dev: true /is-string/1.0.7: resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} @@ -6730,6 +6558,16 @@ packages: engines: {node: '>=6'} dev: false + /jake/10.8.5: + resolution: {integrity: sha512-sVpxYeuAhWt0OTWITwT98oyV0GsXyMlXCF+3L1SuafBVUIr/uILGRB+NqwkzhgXKvoJpDIpQvqkUALgdmQsQxw==} + engines: {node: '>=10'} + hasBin: true + dependencies: + async: 3.2.3 + chalk: 4.1.2 + filelist: 1.0.4 + minimatch: 3.1.2 + /jest-changed-files/27.4.2: resolution: {integrity: sha512-/9x8MjekuzUQoPjDHbBiXbNEBauhrPU2ct7m8TfCg69ywt1y/N+yYwGh3gCpnqUS3klYWDU/lSNgv+JhoD2k1A==} engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} @@ -7166,22 +7004,21 @@ packages: string-length: 4.0.2 dev: true - /jest-worker/24.9.0: - resolution: {integrity: sha512-51PE4haMSXcHohnSMdM42anbvZANYTqMrr52tVKPqqsPJMzoP6FYYDVqahX/HrAoKEKz3uUPzSvKs9A3qR4iVw==} - engines: {node: '>= 6'} + /jest-worker/26.6.2: + resolution: {integrity: sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==} + engines: {node: '>= 10.13.0'} dependencies: + '@types/node': 17.0.35 merge-stream: 2.0.0 - supports-color: 6.1.0 - dev: false + supports-color: 7.2.0 /jest-worker/27.4.6: resolution: {integrity: sha512-gHWJF/6Xi5CTG5QCvROr6GcmpIqNYpDJyc8A1h/DyXqH1tD6SnRCM0d3U5msV31D2LB/U+E0M+W4oyvKV44oNw==} engines: {node: '>= 10.13.0'} dependencies: - '@types/node': 16.11.21 + '@types/node': 17.0.35 merge-stream: 2.0.0 supports-color: 8.1.1 - dev: true /jest/27.4.7_ts-node@10.4.0: resolution: {integrity: sha512-8heYvsx7nV/m8m24Vk26Y87g73Ba6ueUd0MWed/NXMhSZIm62U/llVbS0PJe1SHunbyXjJ/BqG1z9bFjGUIvTg==} @@ -7270,7 +7107,6 @@ packages: /jsesc/0.5.0: resolution: {integrity: sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=} hasBin: true - dev: false /jsesc/2.5.2: resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} @@ -7290,7 +7126,9 @@ packages: /json-schema-traverse/1.0.0: resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} - dev: true + + /json-schema/0.4.0: + resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} /json-stable-stringify-without-jsonify/1.0.1: resolution: {integrity: sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=} @@ -7301,6 +7139,7 @@ packages: hasBin: true dependencies: minimist: 1.2.6 + dev: true /json5/2.2.0: resolution: {integrity: sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==} @@ -7326,6 +7165,10 @@ packages: optionalDependencies: graceful-fs: 4.2.9 + /jsonpointer/5.0.0: + resolution: {integrity: sha512-PNYZIdMjVIvVgDSYKTT63Y+KZ6IZvGRNNWcxwD+GNnUz1MKPfv30J8ueCjdwcN0nDx2SlshgyB7Oy0epAzVRRg==} + engines: {node: '>=0.10.0'} + /jsonwebtoken/8.5.1: resolution: {integrity: sha512-XjwVfRS6jTMsqYs0EsuJ4LGxXV14zQybNd4L2r0UvbVnSF9Af8x7p5MzbJ90Ioz/9TI41/hTCvznF/loiSzn8w==} engines: {node: '>=4', npm: '>=1.4.28'} @@ -7410,7 +7253,6 @@ packages: /leven/3.1.0: resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} engines: {node: '>=6'} - dev: true /levn/0.3.0: resolution: {integrity: sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=} @@ -7511,15 +7353,6 @@ packages: engines: {node: '>=6.11.5'} dev: true - /loader-utils/1.4.0: - resolution: {integrity: sha512-qH0WSMBtn/oHuwjy/NucEgbx5dbxxnxup9s4PVXJUDHZBQY+s0NWA9rJf53RBnQZxfch7euUui7hpoAPvALZdA==} - engines: {node: '>=4.0.0'} - dependencies: - big.js: 5.2.2 - emojis-list: 3.0.0 - json5: 1.0.1 - dev: false - /loader-utils/2.0.0: resolution: {integrity: sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==} engines: {node: '>=8.9.0'} @@ -7537,28 +7370,14 @@ packages: path-exists: 3.0.0 dev: true - /locate-path/3.0.0: - resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==} - engines: {node: '>=6'} - dependencies: - p-locate: 3.0.0 - path-exists: 3.0.0 - dev: false - /locate-path/5.0.0: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} dependencies: p-locate: 4.1.0 - dev: true - - /lodash._reinterpolate/3.0.0: - resolution: {integrity: sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=} - dev: false /lodash.debounce/4.0.8: resolution: {integrity: sha1-gteb/zCmfEAF/9XiUVMArZyk168=} - dev: false /lodash.defaults/4.2.0: resolution: {integrity: sha1-0JF4cW/+pN3p5ft7N/bwgCJ0WAw=} @@ -7604,18 +7423,8 @@ packages: resolution: {integrity: sha1-DdOXEhPHxW34gJd9UEyI+0cal6w=} dev: false - /lodash.template/4.5.0: - resolution: {integrity: sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==} - dependencies: - lodash._reinterpolate: 3.0.0 - lodash.templatesettings: 4.2.0 - dev: false - - /lodash.templatesettings/4.2.0: - resolution: {integrity: sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==} - dependencies: - lodash._reinterpolate: 3.0.0 - dev: false + /lodash.sortby/4.7.0: + resolution: {integrity: sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=} /lodash.throttle/4.1.1: resolution: {integrity: sha1-wj6RtxAkKscMN/HhzaknTMOb8vQ=} @@ -7704,20 +7513,11 @@ packages: resolution: {integrity: sha512-X5Opjm2xcZsOLuJ+Bnhb4t5yfu4ehlA3OKEYLtqUchgVzL/QaqW373ZUVxVHKwvJ38cmYuR4rAHD2yUvAIkTPA==} dev: false - /make-dir/2.1.0: - resolution: {integrity: sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==} - engines: {node: '>=6'} - dependencies: - pify: 4.0.1 - semver: 5.7.1 - dev: false - /make-dir/3.1.0: resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} engines: {node: '>=8'} dependencies: semver: 6.3.0 - dev: true /make-error/1.3.6: resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} @@ -7839,7 +7639,6 @@ packages: /merge2/1.4.1: resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} engines: {node: '>= 8'} - dev: true /methods/1.1.2: resolution: {integrity: sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=} @@ -7851,7 +7650,6 @@ packages: dependencies: braces: 3.0.2 picomatch: 2.3.1 - dev: true /mime-db/1.51.0: resolution: {integrity: sha512-5y8A56jg7XVQx2mbv1lu49NR4dokRnhZYTtL+KGfaa27uq4pSTXkwQkFJl4pkRMyNFz/EtYDSkiiEHx3F7UN6g==} @@ -7894,6 +7692,12 @@ packages: dependencies: brace-expansion: 1.1.11 + /minimatch/5.1.0: + resolution: {integrity: sha512-9TPBGGak4nHfGZsPBohm9AWg6NoT7QTCehS3BIJABslyZbzxfV78QM2Y6+i741OPZIafFAaiiEMh5OyIrJPgtg==} + engines: {node: '>=10'} + dependencies: + brace-expansion: 2.0.1 + /minimist-options/4.1.0: resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==} engines: {node: '>= 6'} @@ -7909,22 +7713,6 @@ packages: /minimist/1.2.6: resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==} - /mississippi/3.0.0: - resolution: {integrity: sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==} - engines: {node: '>=4.0.0'} - dependencies: - concat-stream: 1.6.2 - duplexify: 3.7.1 - end-of-stream: 1.4.4 - flush-write-stream: 1.1.1 - from2: 2.3.0 - parallel-transform: 1.2.0 - pump: 3.0.0 - pumpify: 1.5.1 - stream-each: 1.2.3 - through2: 2.0.5 - dev: false - /mkdirp/0.5.5: resolution: {integrity: sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==} hasBin: true @@ -7938,17 +7726,6 @@ packages: hasBin: true dev: false - /move-concurrently/1.0.1: - resolution: {integrity: sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=} - dependencies: - aproba: 1.2.0 - copy-concurrently: 1.0.5 - fs-write-stream-atomic: 1.0.10 - mkdirp: 0.5.5 - rimraf: 2.7.1 - run-queue: 1.0.3 - dev: false - /ms/2.0.0: resolution: {integrity: sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=} @@ -8045,18 +7822,27 @@ packages: engines: {node: '>= 0.4.0'} dev: false - /next-offline/5.0.5_next@12.0.10: - resolution: {integrity: sha512-GOpq+mD7ecrgW+A8+Y31BLNca3b8EeyRMhW5C9PsCc/C2RO1AzrssgIgQIrRulFuXDvXuPE5hWI4/DTHeOUp6Q==} + /next-pwa/5.5.2_next@12.0.10: + resolution: {integrity: sha512-NOZxIS/4Qa4lsPG99CNh3ZA1vfVJ3vpZjBvfouXOfWn0K9CLjBRZwGkJAcWsMWngSGoTN1hUkg97Pe+9xESzWQ==} peerDependencies: - next: '>=7.0.0' - webpack: ^4.19.1 + next: '>=9.0.0' dependencies: - copy-webpack-plugin: 5.1.2 - fs-extra: 8.1.0 + babel-loader: 8.2.5 + clean-webpack-plugin: 4.0.0 + globby: 11.1.0 next: 12.0.10_react-dom@17.0.2+react@17.0.2 - workbox-webpack-plugin: 5.1.4 + terser-webpack-plugin: 5.3.1 + workbox-webpack-plugin: 6.5.3 + workbox-window: 6.5.3 transitivePeerDependencies: + - '@babel/core' + - '@swc/core' + - '@types/babel__core' + - acorn + - esbuild - supports-color + - uglify-js + - webpack dev: false /next/12.0.10_react-dom@17.0.2+react@17.0.2: @@ -8128,7 +7914,6 @@ packages: /node-releases/2.0.4: resolution: {integrity: sha512-gbMzqQtTtDz/00jQzZ21PQzdI9PyLYqUSvD0p3naOhX4odFji0ZxYdnVwPTxmSwkmxhcFImpozceidSG+AgoPQ==} - dev: false /normalize-package-data/2.5.0: resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} @@ -8355,19 +8140,16 @@ packages: p-limit: 1.3.0 dev: true - /p-locate/3.0.0: - resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==} - engines: {node: '>=6'} - dependencies: - p-limit: 2.3.0 - dev: false - /p-locate/4.1.0: resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} engines: {node: '>=8'} dependencies: p-limit: 2.3.0 - dev: true + + /p-map/2.1.0: + resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==} + engines: {node: '>=6'} + dev: false /p-map/4.0.0: resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} @@ -8411,14 +8193,6 @@ packages: netmask: 2.0.2 dev: false - /parallel-transform/1.2.0: - resolution: {integrity: sha512-P2vSmIu38uIlvdcU7fDkyrxj33gTUy/ABO5ZUbGowxNCopBq/OoD42bP4UmMrJoPyk4Uqf0mu3mtWBhHCZD8yg==} - dependencies: - cyclist: 1.0.1 - inherits: 2.0.4 - readable-stream: 2.3.7 - dev: false - /parent-module/1.0.1: resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} engines: {node: '>=6'} @@ -8474,23 +8248,23 @@ packages: pause: 0.0.1 dev: false - /path-dirname/1.0.2: - resolution: {integrity: sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=} - dev: false - /path-exists/3.0.0: resolution: {integrity: sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=} engines: {node: '>=4'} + dev: true /path-exists/4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} - dev: true /path-is-absolute/1.0.1: resolution: {integrity: sha1-F0uSaHNVNP+8es5r9TpanhtcX18=} engines: {node: '>=0.10.0'} + /path-is-inside/1.0.2: + resolution: {integrity: sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=} + dev: false + /path-key/3.1.1: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} @@ -8506,17 +8280,9 @@ packages: resolution: {integrity: sha512-jczvQbCUS7XmS7o+y1aEO9OBVFeZBQ1MDSEqmO7xSoPgOPoowY/SxLpZ6Vh97/8qHZOteiCKb7gkG9gA2ZUxJA==} dev: false - /path-type/3.0.0: - resolution: {integrity: sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==} - engines: {node: '>=4'} - dependencies: - pify: 3.0.0 - dev: false - /path-type/4.0.0: resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} engines: {node: '>=8'} - dev: true /pause-stream/0.0.11: resolution: {integrity: sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=} @@ -8554,9 +8320,9 @@ packages: hasBin: true dev: true - /pify/3.0.0: - resolution: {integrity: sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=} - engines: {node: '>=4'} + /pify/2.3.0: + resolution: {integrity: sha1-7RQaasBDqEnqWISY59yosVMw6Qw=} + engines: {node: '>=0.10.0'} dev: false /pify/4.0.1: @@ -8564,24 +8330,28 @@ packages: engines: {node: '>=6'} dev: false + /pinkie-promise/2.0.1: + resolution: {integrity: sha1-ITXW36ejWMBprJsXh3YogihFD/o=} + engines: {node: '>=0.10.0'} + dependencies: + pinkie: 2.0.4 + dev: false + + /pinkie/2.0.4: + resolution: {integrity: sha1-clVrgM+g1IqXToDnckjoDtT3+HA=} + engines: {node: '>=0.10.0'} + dev: false + /pirates/4.0.5: resolution: {integrity: sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==} engines: {node: '>= 6'} dev: true - /pkg-dir/3.0.0: - resolution: {integrity: sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==} - engines: {node: '>=6'} - dependencies: - find-up: 3.0.0 - dev: false - /pkg-dir/4.2.0: resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} engines: {node: '>=8'} dependencies: find-up: 4.1.0 - dev: true /platform/1.3.6: resolution: {integrity: sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==} @@ -8717,7 +8487,6 @@ packages: /pretty-bytes/5.6.0: resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==} engines: {node: '>=6'} - dev: false /pretty-format/27.4.6: resolution: {integrity: sha512-NblstegA1y/RJW2VyML+3LlpFjzx62cUrtBIKIWDXEDkjNeleA7Od7nrzcs/VLQvAeV4CgSYhrN39DRN88Qi/g==} @@ -8732,10 +8501,6 @@ packages: resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} dev: false - /promise-inflight/1.0.1: - resolution: {integrity: sha1-mEcocL8igTL8vdhoEputEsPAKeM=} - dev: false - /prompts/2.4.2: resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} engines: {node: '>= 6'} @@ -8890,27 +8655,12 @@ packages: resolution: {integrity: sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==} dev: true - /pump/2.0.1: - resolution: {integrity: sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==} - dependencies: - end-of-stream: 1.4.4 - once: 1.4.0 - dev: false - /pump/3.0.0: resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} dependencies: end-of-stream: 1.4.4 once: 1.4.0 - /pumpify/1.5.1: - resolution: {integrity: sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==} - dependencies: - duplexify: 3.7.1 - inherits: 2.0.4 - pump: 2.0.1 - dev: false - /punycode/2.1.1: resolution: {integrity: sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==} engines: {node: '>=6'} @@ -8933,7 +8683,6 @@ packages: /queue-microtask/1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} - dev: true /quick-lru/4.0.1: resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} @@ -9220,25 +8969,17 @@ packages: engines: {node: '>=4'} dependencies: regenerate: 1.4.2 - dev: false /regenerate/1.4.2: resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==} - dev: false - - /regenerator-runtime/0.11.1: - resolution: {integrity: sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==} - dev: false /regenerator-runtime/0.13.9: resolution: {integrity: sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==} - dev: false /regenerator-transform/0.15.0: resolution: {integrity: sha512-LsrGtPmbYg19bcPHwdtmXwbW+TqNvtY4riE3P83foeHRroMbH6/2ddFBfab3t7kbzc7v7p4wbkIecHImqt0QNg==} dependencies: '@babel/runtime': 7.16.7 - dev: false /regexp.prototype.flags/1.4.1: resolution: {integrity: sha512-pMR7hBVUUGI7PMA37m2ofIdQCsomVnas+Jn5UPGAHQ+/LlwKm/aTLJHdasmHRzlfeZwHiAOaRSo2rbBDm3nNUQ==} @@ -9262,18 +9003,15 @@ packages: regjsparser: 0.8.4 unicode-match-property-ecmascript: 2.0.0 unicode-match-property-value-ecmascript: 2.0.0 - dev: false /regjsgen/0.6.0: resolution: {integrity: sha512-ozE883Uigtqj3bx7OhL1KNbCzGyW2NQZPl6Hs09WTvCuZD5sTI4JY58bkbQWa/Y9hxIsvJ3M8Nbf7j54IqeZbA==} - dev: false /regjsparser/0.8.4: resolution: {integrity: sha512-J3LABycON/VNEu3abOviqGHuB/LOtOQj8SKmfP9anY5GfAVw/SPjwzSjxGjbZXIxbGfqTHtJw58C2Li/WkStmA==} hasBin: true dependencies: jsesc: 0.5.0 - dev: false /require-directory/2.1.1: resolution: {integrity: sha1-jGStX9MNqxyXbiNE/+f3kqam30I=} @@ -9282,7 +9020,6 @@ packages: /require-from-string/2.0.2: resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} engines: {node: '>=0.10.0'} - dev: true /resize-observer-polyfill/1.5.1: resolution: {integrity: sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg==} @@ -9336,7 +9073,6 @@ packages: /reusify/1.0.4: resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} engines: {iojs: '>=1.0.0', node: '>=0.10.0'} - dev: true /rfdc/1.3.0: resolution: {integrity: sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==} @@ -9355,46 +9091,25 @@ packages: dependencies: glob: 7.2.0 - /rollup-plugin-babel/4.4.0_956cf004975a500cc8181c5269930d2b: - resolution: {integrity: sha512-Lek/TYp1+7g7I+uMfJnnSJ7YWoD58ajo6Oarhlex7lvUce+RCKRuGRSgztDO3/MF/PuGKmUL5iTHKf208UNszw==} - deprecated: This package has been deprecated and is no longer maintained. Please use @rollup/plugin-babel. + /rollup-plugin-terser/7.0.2_rollup@2.74.1: + resolution: {integrity: sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==} peerDependencies: - '@babel/core': 7 || ^7.0.0-rc.2 - rollup: '>=0.60.0 <3' - dependencies: - '@babel/core': 7.16.12 - '@babel/helper-module-imports': 7.16.7 - rollup: 1.32.1 - rollup-pluginutils: 2.8.2 - dev: false - - /rollup-plugin-terser/5.3.1_rollup@1.32.1: - resolution: {integrity: sha512-1pkwkervMJQGFYvM9nscrUoncPwiKR/K+bHdjv6PFgRo3cgPHoRT83y2Aa3GvINj4539S15t/tpFPb775TDs6w==} - peerDependencies: - rollup: '>=0.66.0 <3' + rollup: ^2.0.0 dependencies: '@babel/code-frame': 7.16.7 - jest-worker: 24.9.0 - rollup: 1.32.1 - rollup-pluginutils: 2.8.2 + jest-worker: 26.6.2 + rollup: 2.74.1 serialize-javascript: 4.0.0 - terser: 4.8.0 - dev: false + terser: 5.10.0 + transitivePeerDependencies: + - acorn - /rollup-pluginutils/2.8.2: - resolution: {integrity: sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==} - dependencies: - estree-walker: 0.6.1 - dev: false - - /rollup/1.32.1: - resolution: {integrity: sha512-/2HA0Ec70TvQnXdzynFffkjA6XN+1e2pEv/uKS5Ulca40g2L7KuOE3riasHoNVHOsFD5KKZgDsMk1CP3Tw9s+A==} + /rollup/2.74.1: + resolution: {integrity: sha512-K2zW7kV8Voua5eGkbnBtWYfMIhYhT9Pel2uhBk2WO5eMee161nPze/XRfvEQPFYz7KgrCCnmh2Wy0AMFLGGmMA==} + engines: {node: '>=10.0.0'} hasBin: true - dependencies: - '@types/estree': 0.0.50 - '@types/node': 17.0.13 - acorn: 7.4.1 - dev: false + optionalDependencies: + fsevents: 2.3.2 /rope-sequence/1.3.2: resolution: {integrity: sha512-ku6MFrwEVSVmXLvy3dYph3LAMNS0890K7fabn+0YIRQ2T96T9F4gkFf0vf0WW0JUraNWwGRtInEpH7yO4tbQZg==} @@ -9409,13 +9124,6 @@ packages: resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} dependencies: queue-microtask: 1.2.3 - dev: true - - /run-queue/1.0.3: - resolution: {integrity: sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=} - dependencies: - aproba: 1.2.0 - dev: false /rxjs/6.6.7: resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==} @@ -9493,15 +9201,6 @@ packages: object-assign: 4.1.1 dev: false - /schema-utils/1.0.0: - resolution: {integrity: sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==} - engines: {node: '>= 4'} - dependencies: - ajv: 6.12.6 - ajv-errors: 1.0.1_ajv@6.12.6 - ajv-keywords: 3.5.2_ajv@6.12.6 - dev: false - /schema-utils/2.7.0: resolution: {integrity: sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==} engines: {node: '>= 8.9.0'} @@ -9527,6 +9226,16 @@ packages: ajv: 6.12.6 ajv-keywords: 3.5.2_ajv@6.12.6 + /schema-utils/4.0.0: + resolution: {integrity: sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==} + engines: {node: '>= 12.13.0'} + dependencies: + '@types/json-schema': 7.0.9 + ajv: 8.8.2 + ajv-formats: 2.1.1 + ajv-keywords: 5.1.0_ajv@8.8.2 + dev: true + /scroll-into-view-if-needed/2.2.29: resolution: {integrity: sha512-hxpAR6AN+Gh53AdAimHM6C8oTN1ppwVZITihix+WqalywBeFcQ6LdQP5ABNl26nX8GTEL7VT+b8lKpdqq65wXg==} dependencies: @@ -9550,7 +9259,6 @@ packages: /semver/7.0.0: resolution: {integrity: sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==} hasBin: true - dev: false /semver/7.3.2: resolution: {integrity: sha512-OrOb32TeeambH6UrhtShmF7CRDqhL6/5XpPNp2DuRH6+9QLw/orhp72j87v8Qa1ScDkvrrBNpZcDejAirJmfXQ==} @@ -9592,13 +9300,11 @@ packages: resolution: {integrity: sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==} dependencies: randombytes: 2.1.0 - dev: false /serialize-javascript/6.0.0: resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} dependencies: randombytes: 2.1.0 - dev: true /serve-static/1.14.2: resolution: {integrity: sha512-+TMNA9AFxUEGuC0z2mevogSnn9MXKb4fa7ngeRMJaaGv8vTwnIEkKi+QGvPt33HSnf8pRS+WGM0EbMtCJLKMBQ==} @@ -9661,14 +9367,13 @@ packages: resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} dev: true - /slash/1.0.0: - resolution: {integrity: sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=} - engines: {node: '>=0.10.0'} - dev: false - /slash/3.0.0: resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} engines: {node: '>=8'} + + /slash/4.0.0: + resolution: {integrity: sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==} + engines: {node: '>=12'} dev: true /slice-ansi/3.0.0: @@ -9723,7 +9428,6 @@ packages: /source-list-map/2.0.1: resolution: {integrity: sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==} - dev: false /source-map-js/1.0.2: resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==} @@ -9735,11 +9439,6 @@ packages: buffer-from: 1.1.2 source-map: 0.6.1 - /source-map-url/0.4.1: - resolution: {integrity: sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==} - deprecated: See https://github.com/lydell/source-map-url#deprecated - dev: false - /source-map/0.5.7: resolution: {integrity: sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=} engines: {node: '>=0.10.0'} @@ -9752,6 +9451,12 @@ packages: resolution: {integrity: sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==} engines: {node: '>= 8'} + /source-map/0.8.0-beta.0: + resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} + engines: {node: '>= 8'} + dependencies: + whatwg-url: 7.1.0 + /sourcemap-codec/1.4.8: resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==} @@ -9795,12 +9500,6 @@ packages: engines: {node: '>= 0.6'} dev: false - /ssri/6.0.2: - resolution: {integrity: sha512-cepbSq/neFK7xB6A50KHN0xHDotYzq58wWCa5LeWqnPrHG8GzfEjO/4O8kpmcGW+oaxkvhEJCWgbgNk4/ZV93Q==} - dependencies: - figgy-pudding: 3.5.2 - dev: false - /stack-utils/2.0.5: resolution: {integrity: sha512-xrQcmYhOsn/1kX+Vraq+7j4oE2j/6BFscZ0etmYg81xuM8Gq0022Pxb8+IqgOFUIaxHs0KaSb7T1+OegiNrNFA==} engines: {node: '>=10'} @@ -9817,13 +9516,6 @@ packages: engines: {node: '>= 0.6'} dev: false - /stream-each/1.2.3: - resolution: {integrity: sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==} - dependencies: - end-of-stream: 1.4.4 - stream-shift: 1.0.1 - dev: false - /stream-http/2.8.2: resolution: {integrity: sha512-QllfrBhqF1DPcz46WxKTs6Mz1Bpc+8Qm6vbqOpVav5odAXwbyzwnEczoWqtxrsmlO+cJqtPrp/8gWKWjaKLLlA==} dependencies: @@ -9834,10 +9526,6 @@ packages: xtend: 4.0.2 dev: false - /stream-shift/1.0.1: - resolution: {integrity: sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==} - dev: false - /stream-wormhole/1.1.0: resolution: {integrity: sha512-gHFfL3px0Kctd6Po0M8TzEvt3De/xu6cnRrjlfYNhwbhLPLwigI2t1nc6jrzNuaYg5C4YF78PPFuQPzRiqn9ew==} engines: {node: '>=4.0.0'} @@ -9889,7 +9577,6 @@ packages: internal-slot: 1.0.3 regexp.prototype.flags: 1.4.1 side-channel: 1.0.4 - dev: true /string.prototype.trimend/1.0.4: resolution: {integrity: sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==} @@ -9926,7 +9613,6 @@ packages: get-own-enumerable-property-symbols: 3.0.2 is-obj: 1.0.1 is-regexp: 1.0.0 - dev: false /strip-ansi/6.0.1: resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} @@ -9951,13 +9637,9 @@ packages: engines: {node: '>=8'} dev: true - /strip-comments/1.0.2: - resolution: {integrity: sha512-kL97alc47hoyIQSV165tTt9rG5dn4w1dNnBhOQ3bOU1Nc1hel09jnXANaHJ7vzHLd4Ju8kseDGzlev96pghLFw==} - engines: {node: '>=4'} - dependencies: - babel-extract-comments: 1.0.0 - babel-plugin-transform-object-rest-spread: 6.26.0 - dev: false + /strip-comments/2.0.1: + resolution: {integrity: sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==} + engines: {node: '>=10'} /strip-final-newline/2.0.0: resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==} @@ -10205,13 +9887,6 @@ packages: dependencies: has-flag: 3.0.0 - /supports-color/6.1.0: - resolution: {integrity: sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==} - engines: {node: '>=6'} - dependencies: - has-flag: 3.0.0 - dev: false - /supports-color/7.2.0: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} @@ -10282,19 +9957,18 @@ packages: resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==} engines: {node: '>=6'} - /temp-dir/1.0.0: - resolution: {integrity: sha1-CnwOom06Oa+n4OvqnB/AvE2qAR0=} - engines: {node: '>=4'} - dev: false - - /tempy/0.3.0: - resolution: {integrity: sha512-WrH/pui8YCwmeiAoxV+lpRH9HpRtgBhSR2ViBPgpGb/wnYDzp21R4MN45fsCGvLROvY67o3byhJRYRONJyImVQ==} + /temp-dir/2.0.0: + resolution: {integrity: sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==} engines: {node: '>=8'} + + /tempy/0.6.0: + resolution: {integrity: sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==} + engines: {node: '>=10'} dependencies: - temp-dir: 1.0.0 - type-fest: 0.3.1 - unique-string: 1.0.0 - dev: false + is-stream: 2.0.1 + temp-dir: 2.0.0 + type-fest: 0.16.0 + unique-string: 2.0.0 /terminal-link/2.1.1: resolution: {integrity: sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==} @@ -10330,15 +10004,44 @@ packages: - acorn dev: true - /terser/4.8.0: - resolution: {integrity: sha512-EAPipTNeWsb/3wLPeup1tVPaXfIaU68xMnVdPafIL1TV05OhASArYyIfFvnvJCNrR2NIOvDVNNTFRa+Re2MWyw==} - engines: {node: '>=6.0.0'} + /terser-webpack-plugin/5.3.1: + resolution: {integrity: sha512-GvlZdT6wPQKbDNW/GDQzZFg/j4vKU96yl2q6mcUkzKOgW4gwf1Z8cZToUCrz31XHlPWH8MVb1r2tFtdDtTGJ7g==} + engines: {node: '>= 10.13.0'} + peerDependencies: + '@swc/core': '*' + esbuild: '*' + uglify-js: '*' + webpack: ^5.1.0 + peerDependenciesMeta: + '@swc/core': + optional: true + esbuild: + optional: true + uglify-js: + optional: true + dependencies: + jest-worker: 27.4.6 + schema-utils: 3.1.1 + serialize-javascript: 6.0.0 + source-map: 0.6.1 + terser: 5.10.0 + transitivePeerDependencies: + - acorn + dev: false + + /terser/5.10.0: + resolution: {integrity: sha512-AMmF99DMfEDiRJfxfY5jj5wNH/bYO09cniSqhfoyxc8sFoYIgkJy86G04UoZU5VjlpnplVu0K6Tx6E9b5+DlHA==} + engines: {node: '>=10'} hasBin: true + peerDependencies: + acorn: ^8.5.0 + peerDependenciesMeta: + acorn: + optional: true dependencies: commander: 2.20.3 - source-map: 0.6.1 + source-map: 0.7.3 source-map-support: 0.5.21 - dev: false /terser/5.10.0_acorn@8.7.0: resolution: {integrity: sha512-AMmF99DMfEDiRJfxfY5jj5wNH/bYO09cniSqhfoyxc8sFoYIgkJy86G04UoZU5VjlpnplVu0K6Tx6E9b5+DlHA==} @@ -10389,13 +10092,6 @@ packages: /through/2.3.8: resolution: {integrity: sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=} - /through2/2.0.5: - resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==} - dependencies: - readable-stream: 2.3.7 - xtend: 4.0.2 - dev: false - /tilg/0.1.1_react@17.0.2: resolution: {integrity: sha512-0uHyTAUM0tJL792LeviRPFkJtCbF6Za3/hbbnRmWGUaicOhbJ0IpvBViXiXTF7nk6R0L6vve2XLesQzn5jEVng==} peerDependencies: @@ -10469,6 +10165,11 @@ packages: resolution: {integrity: sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=} dev: false + /tr46/1.0.1: + resolution: {integrity: sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=} + dependencies: + punycode: 2.1.1 + /tr46/2.1.0: resolution: {integrity: sha512-15Ih7phfcdP5YxqiB+iDtLoaTz4Nd35+IiAv0kQ5FNKHzXgdWqPoTIqEDDJmXceQt4JZk6lVPT8lnDlPpGDppw==} engines: {node: '>=8'} @@ -10623,6 +10324,10 @@ packages: engines: {node: '>=4'} dev: true + /type-fest/0.16.0: + resolution: {integrity: sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==} + engines: {node: '>=10'} + /type-fest/0.18.1: resolution: {integrity: sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==} engines: {node: '>=10'} @@ -10638,11 +10343,6 @@ packages: engines: {node: '>=10'} dev: true - /type-fest/0.3.1: - resolution: {integrity: sha512-cUGJnCdr4STbePCgqNFbpVNCepa+kAVohJs1sLhxzdH+gnEoOd8VhbYa7pD3zZYGiURWM2xzEII3fQcRizDkYQ==} - engines: {node: '>=6'} - dev: false - /type-fest/0.6.0: resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==} engines: {node: '>=8'} @@ -10782,7 +10482,6 @@ packages: /unicode-canonical-property-names-ecmascript/2.0.0: resolution: {integrity: sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==} engines: {node: '>=4'} - dev: false /unicode-match-property-ecmascript/2.0.0: resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==} @@ -10790,36 +10489,20 @@ packages: dependencies: unicode-canonical-property-names-ecmascript: 2.0.0 unicode-property-aliases-ecmascript: 2.0.0 - dev: false /unicode-match-property-value-ecmascript/2.0.0: resolution: {integrity: sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==} engines: {node: '>=4'} - dev: false /unicode-property-aliases-ecmascript/2.0.0: resolution: {integrity: sha512-5Zfuy9q/DFr4tfO7ZPeVXb1aPoeQSdeFMLpYuFebehDAhbuevLs5yxSZmIFN1tP5F9Wl4IpJrYojg85/zgyZHQ==} engines: {node: '>=4'} - dev: false - /unique-filename/1.1.1: - resolution: {integrity: sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==} + /unique-string/2.0.0: + resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==} + engines: {node: '>=8'} dependencies: - unique-slug: 2.0.2 - dev: false - - /unique-slug/2.0.2: - resolution: {integrity: sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w==} - dependencies: - imurmurhash: 0.1.4 - dev: false - - /unique-string/1.0.0: - resolution: {integrity: sha1-nhBXzKhRq7kzmPizOuGHuZyuwRo=} - engines: {node: '>=4'} - dependencies: - crypto-random-string: 1.0.0 - dev: false + crypto-random-string: 2.0.0 /universalify/0.1.2: resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} @@ -10837,7 +10520,6 @@ packages: /upath/1.2.0: resolution: {integrity: sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==} engines: {node: '>=4'} - dev: false /uri-js/4.4.1: resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} @@ -10907,12 +10589,6 @@ packages: engines: {node: '>= 0.4.0'} dev: false - /uuid/3.4.0: - resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==} - deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. - hasBin: true - dev: false - /uuid/8.3.2: resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==} hasBin: true @@ -10999,6 +10675,9 @@ packages: resolution: {integrity: sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=} dev: false + /webidl-conversions/4.0.2: + resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} + /webidl-conversions/5.0.0: resolution: {integrity: sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==} engines: {node: '>=8'} @@ -11009,14 +10688,6 @@ packages: engines: {node: '>=10.4'} dev: true - /webpack-log/2.0.0: - resolution: {integrity: sha512-cX8G2vR/85UYG59FgkoMamwHUIkSSlV3bBMRsbxVXVUk2j6NleCKjQ/WE9eYg9WY4w25O9w8wKP4rzNZFmUcUg==} - engines: {node: '>= 6'} - dependencies: - ansi-colors: 3.2.4 - uuid: 3.4.0 - dev: false - /webpack-node-externals/3.0.0: resolution: {integrity: sha512-LnL6Z3GGDPht/AigwRh2dvL9PQPFQ8skEpVrWZXLWBYmqcaojHNN0onvHzie6rq7EWKrrBfPYqNEzTJgiwEQDQ==} engines: {node: '>=6'} @@ -11027,7 +10698,6 @@ packages: dependencies: source-list-map: 2.0.1 source-map: 0.6.1 - dev: false /webpack-sources/3.2.3: resolution: {integrity: sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==} @@ -11091,6 +10761,13 @@ packages: webidl-conversions: 3.0.1 dev: false + /whatwg-url/7.1.0: + resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==} + dependencies: + lodash.sortby: 4.7.0 + tr46: 1.0.1 + webidl-conversions: 4.0.2 + /whatwg-url/8.7.0: resolution: {integrity: sha512-gAojqb/m9Q8a5IV96E3fHJM70AzCkgt4uXYX2O7EmuyOnLrViCQlsEBmF9UQIu3/aeAIp2U17rtbpZWNntQqdg==} engines: {node: '>=10'} @@ -11162,150 +10839,152 @@ packages: resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==} engines: {node: '>=0.10.0'} - /workbox-background-sync/5.1.4: - resolution: {integrity: sha512-AH6x5pYq4vwQvfRDWH+vfOePfPIYQ00nCEB7dJRU1e0n9+9HMRyvI63FlDvtFT2AvXVRsXvUt7DNMEToyJLpSA==} + /workbox-background-sync/6.5.3: + resolution: {integrity: sha512-0DD/V05FAcek6tWv9XYj2w5T/plxhDSpclIcAGjA/b7t/6PdaRkQ7ZgtAX6Q/L7kV7wZ8uYRJUoH11VjNipMZw==} dependencies: - workbox-core: 5.1.4 - dev: false + idb: 6.1.5 + workbox-core: 6.5.3 - /workbox-broadcast-update/5.1.4: - resolution: {integrity: sha512-HTyTWkqXvHRuqY73XrwvXPud/FN6x3ROzkfFPsRjtw/kGZuZkPzfeH531qdUGfhtwjmtO/ZzXcWErqVzJNdXaA==} + /workbox-broadcast-update/6.5.3: + resolution: {integrity: sha512-4AwCIA5DiDrYhlN+Miv/fp5T3/whNmSL+KqhTwRBTZIL6pvTgE4lVuRzAt1JltmqyMcQ3SEfCdfxczuI4kwFQg==} dependencies: - workbox-core: 5.1.4 - dev: false + workbox-core: 6.5.3 - /workbox-build/5.1.4: - resolution: {integrity: sha512-xUcZn6SYU8usjOlfLb9Y2/f86Gdo+fy1fXgH8tJHjxgpo53VVsqRX0lUDw8/JuyzNmXuo8vXX14pXX2oIm9Bow==} - engines: {node: '>=8.0.0'} + /workbox-build/6.5.3: + resolution: {integrity: sha512-8JNHHS7u13nhwIYCDea9MNXBNPHXCs5KDZPKI/ZNTr3f4sMGoD7hgFGecbyjX1gw4z6e9bMpMsOEJNyH5htA/w==} + engines: {node: '>=10.0.0'} dependencies: + '@apideck/better-ajv-errors': 0.3.3_ajv@8.8.2 '@babel/core': 7.16.12 '@babel/preset-env': 7.17.12_@babel+core@7.16.12 '@babel/runtime': 7.16.7 - '@hapi/joi': 15.1.1 - '@rollup/plugin-node-resolve': 7.1.3_rollup@1.32.1 - '@rollup/plugin-replace': 2.4.2_rollup@1.32.1 - '@surma/rollup-plugin-off-main-thread': 1.4.2 + '@rollup/plugin-babel': 5.3.1_04044e04815e91b52200805e849584d4 + '@rollup/plugin-node-resolve': 11.2.1_rollup@2.74.1 + '@rollup/plugin-replace': 2.4.2_rollup@2.74.1 + '@surma/rollup-plugin-off-main-thread': 2.2.3 + ajv: 8.8.2 common-tags: 1.8.2 fast-json-stable-stringify: 2.1.0 - fs-extra: 8.1.0 + fs-extra: 9.1.0 glob: 7.2.0 - lodash.template: 4.5.0 + lodash: 4.17.21 pretty-bytes: 5.6.0 - rollup: 1.32.1 - rollup-plugin-babel: 4.4.0_956cf004975a500cc8181c5269930d2b - rollup-plugin-terser: 5.3.1_rollup@1.32.1 - source-map: 0.7.3 - source-map-url: 0.4.1 + rollup: 2.74.1 + rollup-plugin-terser: 7.0.2_rollup@2.74.1 + source-map: 0.8.0-beta.0 stringify-object: 3.3.0 - strip-comments: 1.0.2 - tempy: 0.3.0 + strip-comments: 2.0.1 + tempy: 0.6.0 upath: 1.2.0 - workbox-background-sync: 5.1.4 - workbox-broadcast-update: 5.1.4 - workbox-cacheable-response: 5.1.4 - workbox-core: 5.1.4 - workbox-expiration: 5.1.4 - workbox-google-analytics: 5.1.4 - workbox-navigation-preload: 5.1.4 - workbox-precaching: 5.1.4 - workbox-range-requests: 5.1.4 - workbox-routing: 5.1.4 - workbox-strategies: 5.1.4 - workbox-streams: 5.1.4 - workbox-sw: 5.1.4 - workbox-window: 5.1.4 + workbox-background-sync: 6.5.3 + workbox-broadcast-update: 6.5.3 + workbox-cacheable-response: 6.5.3 + workbox-core: 6.5.3 + workbox-expiration: 6.5.3 + workbox-google-analytics: 6.5.3 + workbox-navigation-preload: 6.5.3 + workbox-precaching: 6.5.3 + workbox-range-requests: 6.5.3 + workbox-recipes: 6.5.3 + workbox-routing: 6.5.3 + workbox-strategies: 6.5.3 + workbox-streams: 6.5.3 + workbox-sw: 6.5.3 + workbox-window: 6.5.3 transitivePeerDependencies: + - '@types/babel__core' + - acorn - supports-color - dev: false - /workbox-cacheable-response/5.1.4: - resolution: {integrity: sha512-0bfvMZs0Of1S5cdswfQK0BXt6ulU5kVD4lwer2CeI+03czHprXR3V4Y8lPTooamn7eHP8Iywi5QjyAMjw0qauA==} + /workbox-cacheable-response/6.5.3: + resolution: {integrity: sha512-6JE/Zm05hNasHzzAGKDkqqgYtZZL2H06ic2GxuRLStA4S/rHUfm2mnLFFXuHAaGR1XuuYyVCEey1M6H3PdZ7SQ==} dependencies: - workbox-core: 5.1.4 - dev: false + workbox-core: 6.5.3 - /workbox-core/5.1.4: - resolution: {integrity: sha512-+4iRQan/1D8I81nR2L5vcbaaFskZC2CL17TLbvWVzQ4qiF/ytOGF6XeV54pVxAvKUtkLANhk8TyIUMtiMw2oDg==} - dev: false + /workbox-core/6.5.3: + resolution: {integrity: sha512-Bb9ey5n/M9x+l3fBTlLpHt9ASTzgSGj6vxni7pY72ilB/Pb3XtN+cZ9yueboVhD5+9cNQrC9n/E1fSrqWsUz7Q==} - /workbox-expiration/5.1.4: - resolution: {integrity: sha512-oDO/5iC65h2Eq7jctAv858W2+CeRW5e0jZBMNRXpzp0ZPvuT6GblUiHnAsC5W5lANs1QS9atVOm4ifrBiYY7AQ==} + /workbox-expiration/6.5.3: + resolution: {integrity: sha512-jzYopYR1zD04ZMdlbn/R2Ik6ixiXbi15c9iX5H8CTi6RPDz7uhvMLZPKEndZTpfgmUk8mdmT9Vx/AhbuCl5Sqw==} dependencies: - workbox-core: 5.1.4 - dev: false + idb: 6.1.5 + workbox-core: 6.5.3 - /workbox-google-analytics/5.1.4: - resolution: {integrity: sha512-0IFhKoEVrreHpKgcOoddV+oIaVXBFKXUzJVBI+nb0bxmcwYuZMdteBTp8AEDJacENtc9xbR0wa9RDCnYsCDLjA==} + /workbox-google-analytics/6.5.3: + resolution: {integrity: sha512-3GLCHotz5umoRSb4aNQeTbILETcrTVEozSfLhHSBaegHs1PnqCmN0zbIy2TjTpph2AGXiNwDrWGF0AN+UgDNTw==} dependencies: - workbox-background-sync: 5.1.4 - workbox-core: 5.1.4 - workbox-routing: 5.1.4 - workbox-strategies: 5.1.4 - dev: false + workbox-background-sync: 6.5.3 + workbox-core: 6.5.3 + workbox-routing: 6.5.3 + workbox-strategies: 6.5.3 - /workbox-navigation-preload/5.1.4: - resolution: {integrity: sha512-Wf03osvK0wTflAfKXba//QmWC5BIaIZARU03JIhAEO2wSB2BDROWI8Q/zmianf54kdV7e1eLaIEZhth4K4MyfQ==} + /workbox-navigation-preload/6.5.3: + resolution: {integrity: sha512-bK1gDFTc5iu6lH3UQ07QVo+0ovErhRNGvJJO/1ngknT0UQ702nmOUhoN9qE5mhuQSrnK+cqu7O7xeaJ+Rd9Tmg==} dependencies: - workbox-core: 5.1.4 - dev: false + workbox-core: 6.5.3 - /workbox-precaching/5.1.4: - resolution: {integrity: sha512-gCIFrBXmVQLFwvAzuGLCmkUYGVhBb7D1k/IL7pUJUO5xacjLcFUaLnnsoVepBGAiKw34HU1y/YuqvTKim9qAZA==} + /workbox-precaching/6.5.3: + resolution: {integrity: sha512-sjNfgNLSsRX5zcc63H/ar/hCf+T19fRtTqvWh795gdpghWb5xsfEkecXEvZ8biEi1QD7X/ljtHphdaPvXDygMQ==} dependencies: - workbox-core: 5.1.4 - dev: false + workbox-core: 6.5.3 + workbox-routing: 6.5.3 + workbox-strategies: 6.5.3 - /workbox-range-requests/5.1.4: - resolution: {integrity: sha512-1HSujLjgTeoxHrMR2muDW2dKdxqCGMc1KbeyGcmjZZAizJTFwu7CWLDmLv6O1ceWYrhfuLFJO+umYMddk2XMhw==} + /workbox-range-requests/6.5.3: + resolution: {integrity: sha512-pGCP80Bpn/0Q0MQsfETSfmtXsQcu3M2QCJwSFuJ6cDp8s2XmbUXkzbuQhCUzKR86ZH2Vex/VUjb2UaZBGamijA==} dependencies: - workbox-core: 5.1.4 - dev: false + workbox-core: 6.5.3 - /workbox-routing/5.1.4: - resolution: {integrity: sha512-8ljknRfqE1vEQtnMtzfksL+UXO822jJlHTIR7+BtJuxQ17+WPZfsHqvk1ynR/v0EHik4x2+826Hkwpgh4GKDCw==} + /workbox-recipes/6.5.3: + resolution: {integrity: sha512-IcgiKYmbGiDvvf3PMSEtmwqxwfQ5zwI7OZPio3GWu4PfehA8jI8JHI3KZj+PCfRiUPZhjQHJ3v1HbNs+SiSkig==} dependencies: - workbox-core: 5.1.4 - dev: false + workbox-cacheable-response: 6.5.3 + workbox-core: 6.5.3 + workbox-expiration: 6.5.3 + workbox-precaching: 6.5.3 + workbox-routing: 6.5.3 + workbox-strategies: 6.5.3 - /workbox-strategies/5.1.4: - resolution: {integrity: sha512-VVS57LpaJTdjW3RgZvPwX0NlhNmscR7OQ9bP+N/34cYMDzXLyA6kqWffP6QKXSkca1OFo/v6v7hW7zrrguo6EA==} + /workbox-routing/6.5.3: + resolution: {integrity: sha512-DFjxcuRAJjjt4T34RbMm3MCn+xnd36UT/2RfPRfa8VWJGItGJIn7tG+GwVTdHmvE54i/QmVTJepyAGWtoLPTmg==} dependencies: - workbox-core: 5.1.4 - workbox-routing: 5.1.4 - dev: false + workbox-core: 6.5.3 - /workbox-streams/5.1.4: - resolution: {integrity: sha512-xU8yuF1hI/XcVhJUAfbQLa1guQUhdLMPQJkdT0kn6HP5CwiPOGiXnSFq80rAG4b1kJUChQQIGPrq439FQUNVrw==} + /workbox-strategies/6.5.3: + resolution: {integrity: sha512-MgmGRrDVXs7rtSCcetZgkSZyMpRGw8HqL2aguszOc3nUmzGZsT238z/NN9ZouCxSzDu3PQ3ZSKmovAacaIhu1w==} dependencies: - workbox-core: 5.1.4 - workbox-routing: 5.1.4 - dev: false + workbox-core: 6.5.3 - /workbox-sw/5.1.4: - resolution: {integrity: sha512-9xKnKw95aXwSNc8kk8gki4HU0g0W6KXu+xks7wFuC7h0sembFnTrKtckqZxbSod41TDaGh+gWUA5IRXrL0ECRA==} - dev: false + /workbox-streams/6.5.3: + resolution: {integrity: sha512-vN4Qi8o+b7zj1FDVNZ+PlmAcy1sBoV7SC956uhqYvZ9Sg1fViSbOpydULOssVJ4tOyKRifH/eoi6h99d+sJ33w==} + dependencies: + workbox-core: 6.5.3 + workbox-routing: 6.5.3 - /workbox-webpack-plugin/5.1.4: - resolution: {integrity: sha512-PZafF4HpugZndqISi3rZ4ZK4A4DxO8rAqt2FwRptgsDx7NF8TVKP86/huHquUsRjMGQllsNdn4FNl8CD/UvKmQ==} - engines: {node: '>=8.0.0'} + /workbox-sw/6.5.3: + resolution: {integrity: sha512-BQBzm092w+NqdIEF2yhl32dERt9j9MDGUTa2Eaa+o3YKL4Qqw55W9yQC6f44FdAHdAJrJvp0t+HVrfh8AiGj8A==} + + /workbox-webpack-plugin/6.5.3: + resolution: {integrity: sha512-Es8Xr02Gi6Kc3zaUwR691ZLy61hz3vhhs5GztcklQ7kl5k2qAusPh0s6LF3wEtlpfs9ZDErnmy5SErwoll7jBA==} + engines: {node: '>=10.0.0'} peerDependencies: - webpack: ^4.0.0 + webpack: ^4.4.0 || ^5.9.0 dependencies: - '@babel/runtime': 7.16.7 fast-json-stable-stringify: 2.1.0 - source-map-url: 0.4.1 + pretty-bytes: 5.6.0 upath: 1.2.0 webpack-sources: 1.4.3 - workbox-build: 5.1.4 + workbox-build: 6.5.3 transitivePeerDependencies: + - '@types/babel__core' + - acorn - supports-color - dev: false - /workbox-window/5.1.4: - resolution: {integrity: sha512-vXQtgTeMCUq/4pBWMfQX8Ee7N2wVC4Q7XYFqLnfbXJ2hqew/cU1uMTD2KqGEgEpE4/30luxIxgE+LkIa8glBYw==} + /workbox-window/6.5.3: + resolution: {integrity: sha512-GnJbx1kcKXDtoJBVZs/P7ddP0Yt52NNy4nocjBpYPiRhMqTpJCNrSL+fGHZ/i/oP6p/vhE8II0sA6AZGKGnssw==} dependencies: - workbox-core: 5.1.4 - dev: false + '@types/trusted-types': 2.0.2 + workbox-core: 6.5.3 /wrap-ansi/6.2.0: resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} @@ -11400,31 +11079,6 @@ packages: engines: {node: '>=0.4'} dev: false - /y-indexeddb/9.0.7_yjs@13.5.24: - resolution: {integrity: sha512-58rDlwtRgXucgR9Kxc49AepAR6uGNGfcvPPAMrmMfSvRBQ/tPnx6NoHNyrRkhbALEAjV9tPEAIP0a/KkVqAIyA==} - peerDependencies: - yjs: ^13.0.0 - dependencies: - lib0: 0.2.47 - yjs: 13.5.24 - dev: false - - /y-prosemirror/1.0.14_50c74ca1ff175066b565400fd8b84eb4: - resolution: {integrity: sha512-fJQn/XT+z/gks9sd64eB+Mf1UQP0d5SHQ8RwbrzIwYFW+FgU/nx8/hJm+nrBAoO9azHOY5aDeoffeLmOFXLD9w==} - peerDependencies: - prosemirror-model: ^1.7.1 - prosemirror-state: ^1.2.3 - prosemirror-view: ^1.9.10 - y-protocols: ^1.0.1 - yjs: ^13.3.2 - dependencies: - lib0: 0.2.47 - prosemirror-model: 1.16.1 - prosemirror-state: 1.3.4 - prosemirror-view: 1.23.6 - yjs: 13.5.24 - dev: false - /y-prosemirror/1.0.14_8fd72c89aecefb95d86a797b5207d945: resolution: {integrity: sha512-fJQn/XT+z/gks9sd64eB+Mf1UQP0d5SHQ8RwbrzIwYFW+FgU/nx8/hJm+nrBAoO9azHOY5aDeoffeLmOFXLD9w==} peerDependencies: @@ -11445,10 +11099,6 @@ packages: lib0: 0.2.47 dev: false - /y18n/4.0.3: - resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==} - dev: false - /y18n/5.0.8: resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} engines: {node: '>=10'}