decocms 2.355.0 → 2.355.1

package/dist/server/node_modules/deepmerge/readme.md

@@ -0,0 +1,264 @@
+# deepmerge
+
+Merges the enumerable properties of two or more objects deeply.
+
+> UMD bundle is 723B minified+gzipped
+
+## Getting Started
+
+### Example Usage
+<!--js
+const merge = require('./')
+-->
+
+```js
+const x = {
+	foo: { bar: 3 },
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}]
+}
+
+const y = {
+	foo: { baz: 4 },
+	quux: 5,
+	array: [{
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}]
+}
+
+const output = {
+	foo: {
+		bar: 3,
+		baz: 4
+	},
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}, {
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}],
+	quux: 5
+}
+
+merge(x, y) // => output
+```
+
+
+### Installation
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm install deepmerge
+```
+
+deepmerge can be used directly in the browser without the use of package managers/bundlers as well:  [UMD version from unpkg.com](https://unpkg.com/deepmerge/dist/umd.js).
+
+
+### Include
+
+deepmerge exposes a CommonJS entry point:
+
+```
+const merge = require('deepmerge')
+```
+
+The ESM entry point was dropped due to a [Webpack bug](https://github.com/webpack/webpack/issues/6584).
+
+# API
+
+
+## `merge(x, y, [options])`
+
+Merge two objects `x` and `y` deeply, returning a new merged object with the
+elements from both `x` and `y`.
+
+If an element at the same key is present for both `x` and `y`, the value from
+`y` will appear in the result.
+
+Merging creates a new object, so that neither `x` or `y` is modified.
+
+**Note:** By default, arrays are merged by concatenating them.
+
+## `merge.all(arrayOfObjects, [options])`
+
+Merges any number of objects into a single result object.
+
+```js
+const foobar = { foo: { bar: 3 } }
+const foobaz = { foo: { baz: 4 } }
+const bar = { bar: 'yay!' }
+
+merge.all([ foobar, foobaz, bar ]) // => { foo: { bar: 3, baz: 4 }, bar: 'yay!' }
+```
+
+
+## Options
+
+### `arrayMerge`
+
+There are multiple ways to merge two arrays, below are a few examples but you can also create your own custom function.
+
+Your `arrayMerge` function will be called with three arguments: a `target` array, the `source` array, and an `options` object with these properties:
+
+- `isMergeableObject(value)`
+- `cloneUnlessOtherwiseSpecified(value, options)`
+
+#### `arrayMerge` example: overwrite target array
+
+Overwrites the existing array values completely rather than concatenating them:
+
+```js
+const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray
+
+merge(
+	[1, 2, 3],
+	[3, 2, 1],
+	{ arrayMerge: overwriteMerge }
+) // => [3, 2, 1]
+```
+
+#### `arrayMerge` example: combine arrays
+
+Combines objects at the same index in the two arrays.
+
+This was the default array merging algorithm pre-version-2.0.0.
+
+```js
+const combineMerge = (target, source, options) => {
+	const destination = target.slice()
+
+	source.forEach((item, index) => {
+		if (typeof destination[index] === 'undefined') {
+			destination[index] = options.cloneUnlessOtherwiseSpecified(item, options)
+		} else if (options.isMergeableObject(item)) {
+			destination[index] = merge(target[index], item, options)
+		} else if (target.indexOf(item) === -1) {
+			destination.push(item)
+		}
+	})
+	return destination
+}
+
+merge(
+	[{ a: true }],
+	[{ b: true }, 'ah yup'],
+	{ arrayMerge: combineMerge }
+) // => [{ a: true, b: true }, 'ah yup']
+```
+
+### `isMergeableObject`
+
+By default, deepmerge clones every property from almost every kind of object.
+
+You may not want this, if your objects are of special types, and you want to copy the whole object instead of just copying its properties.
+
+You can accomplish this by passing in a function for the `isMergeableObject` option.
+
+If you only want to clone properties of plain objects, and ignore all "special" kinds of instantiated objects, you probably want to drop in [`is-plain-object`](https://github.com/jonschlinkert/is-plain-object).
+
+```js
+const { isPlainObject } = require('is-plain-object')
+
+function SuperSpecial() {
+	this.special = 'oh yeah man totally'
+}
+
+const instantiatedSpecialObject = new SuperSpecial()
+
+const target = {
+	someProperty: {
+		cool: 'oh for sure'
+	}
+}
+
+const source = {
+	someProperty: instantiatedSpecialObject
+}
+
+const defaultOutput = merge(target, source)
+
+defaultOutput.someProperty.cool // => 'oh for sure'
+defaultOutput.someProperty.special // => 'oh yeah man totally'
+defaultOutput.someProperty instanceof SuperSpecial // => false
+
+const customMergeOutput = merge(target, source, {
+	isMergeableObject: isPlainObject
+})
+
+customMergeOutput.someProperty.cool // => undefined
+customMergeOutput.someProperty.special // => 'oh yeah man totally'
+customMergeOutput.someProperty instanceof SuperSpecial // => true
+```
+
+### `customMerge`
+
+Specifies a function which can be used to override the default merge behavior for a property, based on the property name.
+
+The `customMerge` function will be passed the key for each property, and should return the function which should be used to merge the values for that property.
+
+It may also return undefined, in which case the default merge behaviour will be used.
+
+```js
+const alex = {
+	name: {
+		first: 'Alex',
+		last: 'Alexson'
+	},
+	pets: ['Cat', 'Parrot']
+}
+
+const tony = {
+	name: {
+		first: 'Tony',
+		last: 'Tonison'
+	},
+	pets: ['Dog']
+}
+
+const mergeNames = (nameA, nameB) => `${nameA.first} and ${nameB.first}`
+
+const options = {
+	customMerge: (key) => {
+		if (key === 'name') {
+			return mergeNames
+		}
+	}
+}
+
+const result = merge(alex, tony, options)
+
+result.name // => 'Alex and Tony'
+result.pets // => ['Cat', 'Parrot', 'Dog']
+```
+
+
+### `clone`
+
+*Deprecated.*
+
+Defaults to `true`.
+
+If `clone` is `false` then child objects will be copied directly instead of being cloned.  This was the default behavior before version 2.x.
+
+
+# Testing
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm test
+```
+
+
+# License
+
+MIT

package/dist/server/node_modules/deepmerge/rollup.config.js

@@ -0,0 +1,22 @@
+import resolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+import pkg from './package.json'
+
+export default {
+	input: `index.js`,
+	plugins: [
+		commonjs(),
+		resolve(),
+	],
+	output: [
+		{
+			file: pkg.main,
+			format: `cjs`
+		},
+		{
+			name: 'deepmerge',
+			file: 'dist/umd.js',
+			format: `umd`
+		},
+	],
+}

package/dist/server/node_modules/figures/index.d.ts

@@ -0,0 +1,279 @@
+declare const figureSet: {
+	readonly tick: string;
+	readonly info: string;
+	readonly warning: string;
+	readonly cross: string;
+	readonly square: string;
+	readonly squareSmall: string;
+	readonly squareSmallFilled: string;
+	readonly squareDarkShade: string;
+	readonly squareMediumShade: string;
+	readonly squareLightShade: string;
+	readonly squareTop: string;
+	readonly squareBottom: string;
+	readonly squareLeft: string;
+	readonly squareRight: string;
+	readonly squareCenter: string;
+	readonly circle: string;
+	readonly circleFilled: string;
+	readonly circleDotted: string;
+	readonly circleDouble: string;
+	readonly circleCircle: string;
+	readonly circleCross: string;
+	readonly circlePipe: string;
+	readonly circleQuestionMark: string;
+	readonly radioOn: string;
+	readonly radioOff: string;
+	readonly checkboxOn: string;
+	readonly checkboxOff: string;
+	readonly checkboxCircleOn: string;
+	readonly checkboxCircleOff: string;
+	readonly questionMarkPrefix: string;
+	readonly bullet: string;
+	readonly dot: string;
+	readonly ellipsis: string;
+	readonly pointer: string;
+	readonly pointerSmall: string;
+	readonly triangleUp: string;
+	readonly triangleUpSmall: string;
+	readonly triangleUpOutline: string;
+	readonly triangleDown: string;
+	readonly triangleDownSmall: string;
+	readonly triangleLeft: string;
+	readonly triangleLeftSmall: string;
+	readonly triangleRight: string;
+	readonly triangleRightSmall: string;
+	readonly lozenge: string;
+	readonly lozengeOutline: string;
+	readonly home: string;
+	readonly hamburger: string;
+	readonly smiley: string;
+	readonly mustache: string;
+	readonly heart: string;
+	readonly star: string;
+	readonly play: string;
+	readonly musicNote: string;
+	readonly musicNoteBeamed: string;
+	readonly nodejs: string;
+	readonly arrowUp: string;
+	readonly arrowDown: string;
+	readonly arrowLeft: string;
+	readonly arrowRight: string;
+	readonly arrowLeftRight: string;
+	readonly arrowUpDown: string;
+	readonly almostEqual: string;
+	readonly notEqual: string;
+	readonly lessOrEqual: string;
+	readonly greaterOrEqual: string;
+	readonly identical: string;
+	readonly infinity: string;
+	readonly subscriptZero: string;
+	readonly subscriptOne: string;
+	readonly subscriptTwo: string;
+	readonly subscriptThree: string;
+	readonly subscriptFour: string;
+	readonly subscriptFive: string;
+	readonly subscriptSix: string;
+	readonly subscriptSeven: string;
+	readonly subscriptEight: string;
+	readonly subscriptNine: string;
+	readonly oneHalf: string;
+	readonly oneThird: string;
+	readonly oneQuarter: string;
+	readonly oneFifth: string;
+	readonly oneSixth: string;
+	readonly oneSeventh: string;
+	readonly oneEighth: string;
+	readonly oneNinth: string;
+	readonly oneTenth: string;
+	readonly twoThirds: string;
+	readonly twoFifths: string;
+	readonly threeQuarters: string;
+	readonly threeFifths: string;
+	readonly threeEighths: string;
+	readonly fourFifths: string;
+	readonly fiveSixths: string;
+	readonly fiveEighths: string;
+	readonly sevenEighth: string;
+	readonly line: string;
+	readonly lineBold: string;
+	readonly lineDouble: string;
+	readonly lineDashed0: string;
+	readonly lineDashed1: string;
+	readonly lineDashed2: string;
+	readonly lineDashed3: string;
+	readonly lineDashed4: string;
+	readonly lineDashed5: string;
+	readonly lineDashed6: string;
+	readonly lineDashed7: string;
+	readonly lineDashed8: string;
+	readonly lineDashed9: string;
+	readonly lineDashed10: string;
+	readonly lineDashed11: string;
+	readonly lineDashed12: string;
+	readonly lineDashed13: string;
+	readonly lineDashed14: string;
+	readonly lineDashed15: string;
+	readonly lineVertical: string;
+	readonly lineVerticalBold: string;
+	readonly lineVerticalDouble: string;
+	readonly lineVerticalDashed0: string;
+	readonly lineVerticalDashed1: string;
+	readonly lineVerticalDashed2: string;
+	readonly lineVerticalDashed3: string;
+	readonly lineVerticalDashed4: string;
+	readonly lineVerticalDashed5: string;
+	readonly lineVerticalDashed6: string;
+	readonly lineVerticalDashed7: string;
+	readonly lineVerticalDashed8: string;
+	readonly lineVerticalDashed9: string;
+	readonly lineVerticalDashed10: string;
+	readonly lineVerticalDashed11: string;
+	readonly lineDownLeft: string;
+	readonly lineDownLeftArc: string;
+	readonly lineDownBoldLeftBold: string;
+	readonly lineDownBoldLeft: string;
+	readonly lineDownLeftBold: string;
+	readonly lineDownDoubleLeftDouble: string;
+	readonly lineDownDoubleLeft: string;
+	readonly lineDownLeftDouble: string;
+	readonly lineDownRight: string;
+	readonly lineDownRightArc: string;
+	readonly lineDownBoldRightBold: string;
+	readonly lineDownBoldRight: string;
+	readonly lineDownRightBold: string;
+	readonly lineDownDoubleRightDouble: string;
+	readonly lineDownDoubleRight: string;
+	readonly lineDownRightDouble: string;
+	readonly lineUpLeft: string;
+	readonly lineUpLeftArc: string;
+	readonly lineUpBoldLeftBold: string;
+	readonly lineUpBoldLeft: string;
+	readonly lineUpLeftBold: string;
+	readonly lineUpDoubleLeftDouble: string;
+	readonly lineUpDoubleLeft: string;
+	readonly lineUpLeftDouble: string;
+	readonly lineUpRight: string;
+	readonly lineUpRightArc: string;
+	readonly lineUpBoldRightBold: string;
+	readonly lineUpBoldRight: string;
+	readonly lineUpRightBold: string;
+	readonly lineUpDoubleRightDouble: string;
+	readonly lineUpDoubleRight: string;
+	readonly lineUpRightDouble: string;
+	readonly lineUpDownLeft: string;
+	readonly lineUpBoldDownBoldLeftBold: string;
+	readonly lineUpBoldDownBoldLeft: string;
+	readonly lineUpDownLeftBold: string;
+	readonly lineUpBoldDownLeftBold: string;
+	readonly lineUpDownBoldLeftBold: string;
+	readonly lineUpDownBoldLeft: string;
+	readonly lineUpBoldDownLeft: string;
+	readonly lineUpDoubleDownDoubleLeftDouble: string;
+	readonly lineUpDoubleDownDoubleLeft: string;
+	readonly lineUpDownLeftDouble: string;
+	readonly lineUpDownRight: string;
+	readonly lineUpBoldDownBoldRightBold: string;
+	readonly lineUpBoldDownBoldRight: string;
+	readonly lineUpDownRightBold: string;
+	readonly lineUpBoldDownRightBold: string;
+	readonly lineUpDownBoldRightBold: string;
+	readonly lineUpDownBoldRight: string;
+	readonly lineUpBoldDownRight: string;
+	readonly lineUpDoubleDownDoubleRightDouble: string;
+	readonly lineUpDoubleDownDoubleRight: string;
+	readonly lineUpDownRightDouble: string;
+	readonly lineDownLeftRight: string;
+	readonly lineDownBoldLeftBoldRightBold: string;
+	readonly lineDownLeftBoldRightBold: string;
+	readonly lineDownBoldLeftRight: string;
+	readonly lineDownBoldLeftBoldRight: string;
+	readonly lineDownBoldLeftRightBold: string;
+	readonly lineDownLeftRightBold: string;
+	readonly lineDownLeftBoldRight: string;
+	readonly lineDownDoubleLeftDoubleRightDouble: string;
+	readonly lineDownDoubleLeftRight: string;
+	readonly lineDownLeftDoubleRightDouble: string;
+	readonly lineUpLeftRight: string;
+	readonly lineUpBoldLeftBoldRightBold: string;
+	readonly lineUpLeftBoldRightBold: string;
+	readonly lineUpBoldLeftRight: string;
+	readonly lineUpBoldLeftBoldRight: string;
+	readonly lineUpBoldLeftRightBold: string;
+	readonly lineUpLeftRightBold: string;
+	readonly lineUpLeftBoldRight: string;
+	readonly lineUpDoubleLeftDoubleRightDouble: string;
+	readonly lineUpDoubleLeftRight: string;
+	readonly lineUpLeftDoubleRightDouble: string;
+	readonly lineUpDownLeftRight: string;
+	readonly lineUpBoldDownBoldLeftBoldRightBold: string;
+	readonly lineUpDownBoldLeftBoldRightBold: string;
+	readonly lineUpBoldDownLeftBoldRightBold: string;
+	readonly lineUpBoldDownBoldLeftRightBold: string;
+	readonly lineUpBoldDownBoldLeftBoldRight: string;
+	readonly lineUpBoldDownLeftRight: string;
+	readonly lineUpDownBoldLeftRight: string;
+	readonly lineUpDownLeftBoldRight: string;
+	readonly lineUpDownLeftRightBold: string;
+	readonly lineUpBoldDownBoldLeftRight: string;
+	readonly lineUpDownLeftBoldRightBold: string;
+	readonly lineUpBoldDownLeftBoldRight: string;
+	readonly lineUpBoldDownLeftRightBold: string;
+	readonly lineUpDownBoldLeftBoldRight: string;
+	readonly lineUpDownBoldLeftRightBold: string;
+	readonly lineUpDoubleDownDoubleLeftDoubleRightDouble: string;
+	readonly lineUpDoubleDownDoubleLeftRight: string;
+	readonly lineUpDownLeftDoubleRightDouble: string;
+	readonly lineCross: string;
+	readonly lineBackslash: string;
+	readonly lineSlash: string;
+};
+
+type FigureSet = typeof figureSet;
+
+/**
+Symbols to use when the terminal supports Unicode symbols.
+*/
+export const mainSymbols: FigureSet;
+
+/**
+Symbols to use when the terminal does not support Unicode symbols.
+*/
+export const fallbackSymbols: FigureSet;
+
+/**
+Symbols to use on any terminal.
+*/
+export default figureSet;
+
+export type Options = {
+	/**
+	Whether to replace symbols with fallbacks.
+
+	This can be set to `true` to always use fallback symbols, whether the terminal has poor Unicode support or not.
+
+	@default `true` if the terminal has poor Unicode support
+	*/
+	readonly useFallback?: boolean;
+};
+
+/**
+Returns the input with replaced fallback symbols if the terminal has poor Unicode support.
+
+@param string - String where the Unicode symbols will be replaced with fallback symbols depending on the terminal.
+@returns The input with replaced fallback Unicode symbols.
+
+@example
+```
+import figures, {replaceSymbols} from 'figures';
+
+console.log(replaceSymbols('✔ check'));
+// On terminals with Unicode symbols:  ✔ check
+// On other terminals:                 √ check
+
+console.log(replaceSymbols('✔ check', {useFallback: true}));
+// On terminals with Unicode symbols:  √ check
+// On other terminals:                 √ check
+```
+*/
+export function replaceSymbols(string: string, options?: Options): string;