From 581e6d66372e0aee4e32b8747d8bc446736b82bb Mon Sep 17 00:00:00 2001 From: Hugues Tennier Date: Fri, 5 Feb 2021 13:24:26 -0500 Subject: [PATCH 1/2] Pass props to other type of serializers --- src/blocksToVue.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/blocksToVue.js b/src/blocksToVue.js index 9a0a704..6d7238e 100644 --- a/src/blocksToVue.js +++ b/src/blocksToVue.js @@ -28,7 +28,7 @@ function blocksToVue(createElement, options) { vueProps = data.mark } else { // If rendering a node, also pass options and original node - vueProps = data.node + vueProps = data.node || data sanityProps._sanityProps = { node: data.node, options: data.options From 40e800b0d4401a58df1e5a753ff617e0236f4eb1 Mon Sep 17 00:00:00 2001 From: Hugues Tennier Date: Fri, 5 Feb 2021 14:35:02 -0500 Subject: [PATCH 2/2] add build files --- .gitignore | 3 - lib/BlockContent.js | 51 +++++++++++ lib/BlockContent.js.map | 1 + lib/blocksToVue.js | 55 +++++++++++ lib/blocksToVue.js.map | 1 + lib/serializers.js | 197 ++++++++++++++++++++++++++++++++++++++++ lib/serializers.js.map | 1 + package-lock.json | 41 ++++++--- 8 files changed, 336 insertions(+), 14 deletions(-) create mode 100644 lib/BlockContent.js create mode 100644 lib/BlockContent.js.map create mode 100644 lib/blocksToVue.js create mode 100644 lib/blocksToVue.js.map create mode 100644 lib/serializers.js create mode 100644 lib/serializers.js.map diff --git a/.gitignore b/.gitignore index f1a08ca..1325d15 100644 --- a/.gitignore +++ b/.gitignore @@ -1,9 +1,6 @@ # Logs *.log -# Compiled files -lib - # Coverage directories used by tools like istanbul coverage .nyc_output diff --git a/lib/BlockContent.js b/lib/BlockContent.js new file mode 100644 index 0000000..f069fb1 --- /dev/null +++ b/lib/BlockContent.js @@ -0,0 +1,51 @@ +'use strict'; + +var blocksToVue = require('./blocksToVue'); + +var component = { + functional: true, + props: { + blocks: { + type: [Array, Object], + required: true + }, + serializers: { + type: Object, + default: function _default() { + return {}; + } + }, + projectId: { + type: String, + default: undefined + }, + dataset: { + type: String, + default: undefined + }, + imageOptions: { + type: Object, + default: function _default() { + return {}; + } + }, + className: { + type: String, + default: undefined + }, + renderContainerOnSingleChild: { + type: Boolean, + default: false + } + }, + render: function render(createElement) { + var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var props = context.props, + data = context.data; + + return blocksToVue(createElement, props); + } +}; + +module.exports = component; +//# sourceMappingURL=BlockContent.js.map \ No newline at end of file diff --git a/lib/BlockContent.js.map b/lib/BlockContent.js.map new file mode 100644 index 0000000..e3b9a34 --- /dev/null +++ b/lib/BlockContent.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../src/BlockContent.js"],"names":["blocksToVue","require","component","functional","props","blocks","type","Array","Object","required","serializers","default","projectId","String","undefined","dataset","imageOptions","className","renderContainerOnSingleChild","Boolean","render","createElement","context","data","module","exports"],"mappings":";;AAAA,IAAMA,cAAcC,QAAQ,eAAR,CAApB;;AAEA,IAAMC,YAAY;AAChBC,cAAY,IADI;AAEhBC,SAAO;AACLC,YAAQ;AACNC,YAAM,CAACC,KAAD,EAAQC,MAAR,CADA;AAENC,gBAAU;AAFJ,KADH;AAKLC,iBAAa;AACXJ,YAAME,MADK;AAEXG,eAAS;AAAA,eAAO,EAAP;AAAA;AAFE,KALR;AASLC,eAAW;AACTN,YAAMO,MADG;AAETF,eAASG;AAFA,KATN;AAaLC,aAAS;AACPT,YAAMO,MADC;AAEPF,eAASG;AAFF,KAbJ;AAiBLE,kBAAc;AACZV,YAAME,MADM;AAEZG,eAAS;AAAA,eAAO,EAAP;AAAA;AAFG,KAjBT;AAqBLM,eAAW;AACTX,YAAMO,MADG;AAETF,eAASG;AAFA,KArBN;AAyBLI,kCAA8B;AAC5BZ,YAAMa,OADsB;AAE5BR,eAAS;AAFmB;AAzBzB,GAFS;AAgChBS,QAhCgB,kBAgCTC,aAhCS,EAgCoB;AAAA,QAAdC,OAAc,uEAAJ,EAAI;AAAA,QAC3BlB,KAD2B,GACZkB,OADY,CAC3BlB,KAD2B;AAAA,QACpBmB,IADoB,GACZD,OADY,CACpBC,IADoB;;AAElC,WAAOvB,YAAYqB,aAAZ,EAA2BjB,KAA3B,CAAP;AACD;AAnCe,CAAlB;;AAsCAoB,OAAOC,OAAP,GAAiBvB,SAAjB","file":"BlockContent.js","sourcesContent":["const blocksToVue = require('./blocksToVue')\n\nconst component = {\n functional: true,\n props: {\n blocks: {\n type: [Array, Object],\n required: true\n },\n serializers: {\n type: Object,\n default: () => ({})\n },\n projectId: {\n type: String,\n default: undefined\n },\n dataset: {\n type: String,\n default: undefined\n },\n imageOptions: {\n type: Object,\n default: () => ({})\n },\n className: {\n type: String,\n default: undefined\n },\n renderContainerOnSingleChild: {\n type: Boolean,\n default: false\n }\n },\n render(createElement, context = {}) {\n const {props, data} = context\n return blocksToVue(createElement, props)\n }\n}\n\nmodule.exports = component\n"]} \ No newline at end of file diff --git a/lib/blocksToVue.js b/lib/blocksToVue.js new file mode 100644 index 0000000..e32f148 --- /dev/null +++ b/lib/blocksToVue.js @@ -0,0 +1,55 @@ +'use strict'; + +var objectAssign = require('object-assign'); + +var _require = require('@sanity/block-content-to-hyperscript/internals'), + blocksToNodes = _require.blocksToNodes; + +var getSerializers = require('./serializers'); + +var isVueComponent = function isVueComponent(block) { + return Object.hasOwnProperty.call(block, 'template') || Object.hasOwnProperty.call(block, 'render') && typeof block.render === 'function'; +}; + +function blocksToVue(createElement, options) { + var renderNode = function renderNode(serializer, properties, children) { + var data = properties || {}; + if (typeof serializer === 'function') { + return serializer(objectAssign({}, data, { + children: children + })); + } + + var tag = serializer; + var childNodes = data.children || children; + childNodes = Array.isArray(childNodes) ? childNodes : [childNodes]; + if (isVueComponent(serializer)) { + var vueProps = {}; + var sanityProps = {}; + if (data.mark) { + // If rendering a mark, we just pass the mark properties + vueProps = data.mark; + } else { + // If rendering a node, also pass options and original node + vueProps = data.node || data; + sanityProps._sanityProps = { + node: data.node, + options: data.options + }; + } + var props = objectAssign({}, vueProps, sanityProps); + data = { props: props }; + } + + return createElement(tag, data, childNodes); + }; + + var _getSerializers = getSerializers(renderNode), + defaultSerializers = _getSerializers.defaultSerializers, + serializeSpan = _getSerializers.serializeSpan; + + return blocksToNodes(renderNode, options, defaultSerializers, serializeSpan); +} + +module.exports = blocksToVue; +//# sourceMappingURL=blocksToVue.js.map \ No newline at end of file diff --git a/lib/blocksToVue.js.map b/lib/blocksToVue.js.map new file mode 100644 index 0000000..88e85e9 --- /dev/null +++ b/lib/blocksToVue.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../src/blocksToVue.js"],"names":["objectAssign","require","blocksToNodes","getSerializers","isVueComponent","Object","hasOwnProperty","call","block","render","blocksToVue","createElement","options","renderNode","serializer","properties","children","data","tag","childNodes","Array","isArray","vueProps","sanityProps","mark","node","_sanityProps","props","defaultSerializers","serializeSpan","module","exports"],"mappings":";;AAAA,IAAMA,eAAeC,QAAQ,eAAR,CAArB;;eACwBA,QAAQ,gDAAR,C;IAAjBC,a,YAAAA,a;;AACP,IAAMC,iBAAiBF,QAAQ,eAAR,CAAvB;;AAEA,IAAMG,iBAAiB,SAAjBA,cAAiB;AAAA,SACrBC,OAAOC,cAAP,CAAsBC,IAAtB,CAA2BC,KAA3B,EAAkC,UAAlC,KACCH,OAAOC,cAAP,CAAsBC,IAAtB,CAA2BC,KAA3B,EAAkC,QAAlC,KAA+C,OAAOA,MAAMC,MAAb,KAAwB,UAFnD;AAAA,CAAvB;;AAIA,SAASC,WAAT,CAAqBC,aAArB,EAAoCC,OAApC,EAA6C;AAC3C,MAAMC,aAAa,SAAbA,UAAa,CAACC,UAAD,EAAaC,UAAb,EAAyBC,QAAzB,EAAsC;AACvD,QAAIC,OAAOF,cAAc,EAAzB;AACA,QAAI,OAAOD,UAAP,KAAsB,UAA1B,EAAsC;AACpC,aAAOA,WACLd,aAAa,EAAb,EAAiBiB,IAAjB,EAAuB;AACrBD;AADqB,OAAvB,CADK,CAAP;AAKD;;AAED,QAAME,MAAMJ,UAAZ;AACA,QAAIK,aAAaF,KAAKD,QAAL,IAAiBA,QAAlC;AACAG,iBAAaC,MAAMC,OAAN,CAAcF,UAAd,IAA4BA,UAA5B,GAAyC,CAACA,UAAD,CAAtD;AACA,QAAIf,eAAeU,UAAf,CAAJ,EAAgC;AAC9B,UAAIQ,WAAW,EAAf;AACA,UAAIC,cAAc,EAAlB;AACA,UAAIN,KAAKO,IAAT,EAAe;AACb;AACAF,mBAAWL,KAAKO,IAAhB;AACD,OAHD,MAGO;AACL;AACAF,mBAAWL,KAAKQ,IAAL,IAAaR,IAAxB;AACAM,oBAAYG,YAAZ,GAA2B;AACzBD,gBAAMR,KAAKQ,IADc;AAEzBb,mBAASK,KAAKL;AAFW,SAA3B;AAID;AACD,UAAMe,QAAQ3B,aAAa,EAAb,EAAiBsB,QAAjB,EAA2BC,WAA3B,CAAd;AACAN,aAAO,EAACU,YAAD,EAAP;AACD;;AAED,WAAOhB,cAAcO,GAAd,EAAmBD,IAAnB,EAAyBE,UAAzB,CAAP;AACD,GAhCD;;AAD2C,wBAmCChB,eAAeU,UAAf,CAnCD;AAAA,MAmCpCe,kBAnCoC,mBAmCpCA,kBAnCoC;AAAA,MAmChBC,aAnCgB,mBAmChBA,aAnCgB;;AAqC3C,SAAO3B,cAAcW,UAAd,EAA0BD,OAA1B,EAAmCgB,kBAAnC,EAAuDC,aAAvD,CAAP;AACD;;AAEDC,OAAOC,OAAP,GAAiBrB,WAAjB","file":"blocksToVue.js","sourcesContent":["const objectAssign = require('object-assign')\nconst {blocksToNodes} = require('@sanity/block-content-to-hyperscript/internals')\nconst getSerializers = require('./serializers')\n\nconst isVueComponent = block =>\n Object.hasOwnProperty.call(block, 'template') ||\n (Object.hasOwnProperty.call(block, 'render') && typeof block.render === 'function')\n\nfunction blocksToVue(createElement, options) {\n const renderNode = (serializer, properties, children) => {\n let data = properties || {}\n if (typeof serializer === 'function') {\n return serializer(\n objectAssign({}, data, {\n children\n })\n )\n }\n\n const tag = serializer\n let childNodes = data.children || children\n childNodes = Array.isArray(childNodes) ? childNodes : [childNodes]\n if (isVueComponent(serializer)) {\n let vueProps = {}\n let sanityProps = {}\n if (data.mark) {\n // If rendering a mark, we just pass the mark properties\n vueProps = data.mark\n } else {\n // If rendering a node, also pass options and original node\n vueProps = data.node || data\n sanityProps._sanityProps = {\n node: data.node,\n options: data.options\n }\n }\n const props = objectAssign({}, vueProps, sanityProps)\n data = {props}\n }\n\n return createElement(tag, data, childNodes)\n }\n\n const {defaultSerializers, serializeSpan} = getSerializers(renderNode)\n\n return blocksToNodes(renderNode, options, defaultSerializers, serializeSpan)\n}\n\nmodule.exports = blocksToVue\n"]} \ No newline at end of file diff --git a/lib/serializers.js b/lib/serializers.js new file mode 100644 index 0000000..6c5ee3c --- /dev/null +++ b/lib/serializers.js @@ -0,0 +1,197 @@ +'use strict'; + +var _require = require('@sanity/block-content-to-hyperscript/internals'), + getImageUrl = _require.getImageUrl; + +var objectAssign = require('object-assign'); + +module.exports = function (h) { + // Low-level block serializer + function BlockSerializer(props) { + var node = props.node, + serializers = props.serializers, + options = props.options, + isInline = props.isInline, + children = props.children; + + var blockType = node._type; + var serializer = serializers.types[blockType]; + if (!serializer) { + throw new Error('Unknown block type "' + blockType + '", please specify a serializer for it in the `serializers.types` prop'); + } + + return h(serializer, { + node: node, + options: options, + isInline: isInline + }, children); + } + + // Low-level span serializer + function SpanSerializer(props) { + var _props$node = props.node, + mark = _props$node.mark, + children = _props$node.children; + + var isPlain = typeof mark === 'string'; + var markType = isPlain ? mark : mark._type; + var serializer = props.serializers.marks[markType]; + if (!serializer) { + // @todo Revert back to throwing errors? + // eslint-disable-next-line no-console + console.warn('Unknown mark type "' + markType + '", please specify a serializer for it in the `serializers.marks` prop'); + return h(props.serializers.markFallback, null, children); + } + + return h(serializer, props.node, children); + } + + // Low-level list serializer + function ListSerializer(props) { + var tag = props.type === 'bullet' ? 'ul' : 'ol'; + return h(tag, null, props.children); + } + + // Low-level list item serializer + function ListItemSerializer(props) { + var children = !props.node.style || props.node.style === 'normal' // Don't wrap plain text in paragraphs inside of a list item + ? props.children // But wrap any other style in whatever the block serializer says to use + : h(props.serializers.types.block, props, props.children); + return h('li', null, children); + } + + // Renderer of an actual block of type `block`. Confusing, we know. + function BlockTypeSerializer(props) { + var style = props.node.style || 'normal'; + + if (/^h\d/.test(style)) { + return h(style, null, props.children); + } + + return style === 'blockquote' ? h('blockquote', null, props.children) : h('p', null, props.children); + } + + // Serializers for things that can be directly attributed to a tag without any props + // We use partial application to do this, passing the tag name as the first argument + function RawMarkSerializer(tag, props) { + return h(tag, null, props.children); + } + + function UnderlineSerializer(props) { + return h('span', { + style: { + textDecoration: 'underline' + } + }, props.children); + } + + function StrikeThroughSerializer(props) { + return h('del', null, props.children); + } + + function LinkSerializer(props) { + return h('a', { + attrs: { + href: props.mark.href + } + }, props.children); + } + + function ImageSerializer(props) { + var img = h('img', { + attrs: { + src: getImageUrl(props) + } + }); + return props.isInline ? img : h('figure', null, img); + } + + // Serializer that recursively calls itself, producing a hyperscript tree of spans + function serializeSpan(span, serializers, index, options) { + if (span === '\n' && serializers.hardBreak) { + return h(serializers.hardBreak, { + key: 'hb-' + index + }); + } + + if (typeof span === 'string') { + return serializers.text ? h(serializers.text, { + key: 'text-' + index + }, span) : span; + } + + var children = void 0; + if (span.children) { + children = { + children: span.children.map(function (child, i) { + return options.serializeNode(child, i, span.children, true); + }) + }; + } + + var serializedNode = objectAssign({}, span, children); + + return h(serializers.span, { + key: span._key || 'span-' + index, + node: serializedNode, + serializers: serializers + }); + } + + var HardBreakSerializer = function HardBreakSerializer() { + return h('br'); + }; + var defaultMarkSerializers = { + strong: RawMarkSerializer.bind(null, 'strong'), + em: RawMarkSerializer.bind(null, 'em'), + code: RawMarkSerializer.bind(null, 'code'), + underline: UnderlineSerializer, + 'strike-through': StrikeThroughSerializer, + link: LinkSerializer + }; + + function ContainerSerializer(props) { + var properties = null; + var containerClass = props.className; + if (containerClass) { + properties = { + class: containerClass + }; + } + return h('div', properties, props.children); + } + + var defaultSerializers = { + // Common overrides + types: { + block: BlockTypeSerializer, + image: ImageSerializer + }, + marks: defaultMarkSerializers, + + // Less common overrides + list: ListSerializer, + listItem: ListItemSerializer, + + block: BlockSerializer, + span: SpanSerializer, + hardBreak: HardBreakSerializer, + + container: ContainerSerializer, + + // When we can't resolve the mark properly, use this renderer as the container + markFallback: 'span', + + // Allow overriding text renderer, but leave undefined to just use plain strings by default + text: undefined, + + // Empty nodes (React uses null, hyperscript with empty strings) + empty: null + }; + + return { + defaultSerializers: defaultSerializers, + serializeSpan: serializeSpan + }; +}; +//# sourceMappingURL=serializers.js.map \ No newline at end of file diff --git a/lib/serializers.js.map b/lib/serializers.js.map new file mode 100644 index 0000000..07f7967 --- /dev/null +++ b/lib/serializers.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../src/serializers.js"],"names":["require","getImageUrl","objectAssign","module","exports","BlockSerializer","props","node","serializers","options","isInline","children","blockType","_type","serializer","types","Error","h","SpanSerializer","mark","isPlain","markType","marks","console","warn","markFallback","ListSerializer","tag","type","ListItemSerializer","style","block","BlockTypeSerializer","test","RawMarkSerializer","UnderlineSerializer","textDecoration","StrikeThroughSerializer","LinkSerializer","attrs","href","ImageSerializer","img","src","serializeSpan","span","index","hardBreak","key","text","map","child","i","serializeNode","serializedNode","_key","HardBreakSerializer","defaultMarkSerializers","strong","bind","em","code","underline","link","ContainerSerializer","properties","containerClass","className","class","defaultSerializers","image","list","listItem","container","undefined","empty"],"mappings":"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","file":"serializers.js","sourcesContent":["const {getImageUrl} = require('@sanity/block-content-to-hyperscript/internals')\nconst objectAssign = require('object-assign')\n\nmodule.exports = h => {\n // Low-level block serializer\n function BlockSerializer(props) {\n const {node, serializers, options, isInline, children} = props\n const blockType = node._type\n const serializer = serializers.types[blockType]\n if (!serializer) {\n throw new Error(\n `Unknown block type \"${blockType}\", please specify a serializer for it in the \\`serializers.types\\` prop`\n )\n }\n\n return h(\n serializer,\n {\n node,\n options,\n isInline\n },\n children\n )\n }\n\n // Low-level span serializer\n function SpanSerializer(props) {\n const {mark, children} = props.node\n const isPlain = typeof mark === 'string'\n const markType = isPlain ? mark : mark._type\n const serializer = props.serializers.marks[markType]\n if (!serializer) {\n // @todo Revert back to throwing errors?\n // eslint-disable-next-line no-console\n console.warn(\n `Unknown mark type \"${markType}\", please specify a serializer for it in the \\`serializers.marks\\` prop`\n )\n return h(props.serializers.markFallback, null, children)\n }\n\n return h(serializer, props.node, children)\n }\n\n // Low-level list serializer\n function ListSerializer(props) {\n const tag = props.type === 'bullet' ? 'ul' : 'ol'\n return h(tag, null, props.children)\n }\n\n // Low-level list item serializer\n function ListItemSerializer(props) {\n const children =\n !props.node.style || props.node.style === 'normal' // Don't wrap plain text in paragraphs inside of a list item\n ? props.children // But wrap any other style in whatever the block serializer says to use\n : h(props.serializers.types.block, props, props.children)\n return h('li', null, children)\n }\n\n // Renderer of an actual block of type `block`. Confusing, we know.\n function BlockTypeSerializer(props) {\n const style = props.node.style || 'normal'\n\n if (/^h\\d/.test(style)) {\n return h(style, null, props.children)\n }\n\n return style === 'blockquote'\n ? h('blockquote', null, props.children)\n : h('p', null, props.children)\n }\n\n // Serializers for things that can be directly attributed to a tag without any props\n // We use partial application to do this, passing the tag name as the first argument\n function RawMarkSerializer(tag, props) {\n return h(tag, null, props.children)\n }\n\n function UnderlineSerializer(props) {\n return h(\n 'span',\n {\n style: {\n textDecoration: 'underline'\n }\n },\n props.children\n )\n }\n\n function StrikeThroughSerializer(props) {\n return h('del', null, props.children)\n }\n\n function LinkSerializer(props) {\n return h(\n 'a',\n {\n attrs: {\n href: props.mark.href\n }\n },\n props.children\n )\n }\n\n function ImageSerializer(props) {\n const img = h('img', {\n attrs: {\n src: getImageUrl(props)\n }\n })\n return props.isInline ? img : h('figure', null, img)\n }\n\n // Serializer that recursively calls itself, producing a hyperscript tree of spans\n function serializeSpan(span, serializers, index, options) {\n if (span === '\\n' && serializers.hardBreak) {\n return h(serializers.hardBreak, {\n key: `hb-${index}`\n })\n }\n\n if (typeof span === 'string') {\n return serializers.text\n ? h(\n serializers.text,\n {\n key: `text-${index}`\n },\n span\n )\n : span\n }\n\n let children\n if (span.children) {\n children = {\n children: span.children.map((child, i) =>\n options.serializeNode(child, i, span.children, true)\n )\n }\n }\n\n const serializedNode = objectAssign({}, span, children)\n\n return h(serializers.span, {\n key: span._key || `span-${index}`,\n node: serializedNode,\n serializers\n })\n }\n\n const HardBreakSerializer = () => h('br')\n const defaultMarkSerializers = {\n strong: RawMarkSerializer.bind(null, 'strong'),\n em: RawMarkSerializer.bind(null, 'em'),\n code: RawMarkSerializer.bind(null, 'code'),\n underline: UnderlineSerializer,\n 'strike-through': StrikeThroughSerializer,\n link: LinkSerializer\n }\n\n function ContainerSerializer(props) {\n let properties = null\n const containerClass = props.className\n if (containerClass) {\n properties = {\n class: containerClass\n }\n }\n return h('div', properties, props.children)\n }\n\n const defaultSerializers = {\n // Common overrides\n types: {\n block: BlockTypeSerializer,\n image: ImageSerializer\n },\n marks: defaultMarkSerializers,\n\n // Less common overrides\n list: ListSerializer,\n listItem: ListItemSerializer,\n\n block: BlockSerializer,\n span: SpanSerializer,\n hardBreak: HardBreakSerializer,\n\n container: ContainerSerializer,\n\n // When we can't resolve the mark properly, use this renderer as the container\n markFallback: 'span',\n\n // Allow overriding text renderer, but leave undefined to just use plain strings by default\n text: undefined,\n\n // Empty nodes (React uses null, hyperscript with empty strings)\n empty: null\n }\n\n return {\n defaultSerializers,\n serializeSpan\n }\n}\n"]} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 7a795e3..27292a9 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2784,7 +2784,8 @@ "ansi-regex": { "version": "2.1.1", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "aproba": { "version": "1.2.0", @@ -2805,12 +2806,14 @@ "balanced-match": { "version": "1.0.0", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "brace-expansion": { "version": "1.1.11", "bundled": true, "dev": true, + "optional": true, "requires": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" @@ -2825,17 +2828,20 @@ "code-point-at": { "version": "1.1.0", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "concat-map": { "version": "0.0.1", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "console-control-strings": { "version": "1.1.0", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "core-util-is": { "version": "1.0.2", @@ -2952,7 +2958,8 @@ "inherits": { "version": "2.0.3", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "ini": { "version": "1.3.5", @@ -2964,6 +2971,7 @@ "version": "1.0.0", "bundled": true, "dev": true, + "optional": true, "requires": { "number-is-nan": "^1.0.0" } @@ -2978,6 +2986,7 @@ "version": "3.0.4", "bundled": true, "dev": true, + "optional": true, "requires": { "brace-expansion": "^1.1.7" } @@ -2985,12 +2994,14 @@ "minimist": { "version": "0.0.8", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "minipass": { "version": "2.2.4", "bundled": true, "dev": true, + "optional": true, "requires": { "safe-buffer": "^5.1.1", "yallist": "^3.0.0" @@ -3009,6 +3020,7 @@ "version": "0.5.1", "bundled": true, "dev": true, + "optional": true, "requires": { "minimist": "0.0.8" } @@ -3089,7 +3101,8 @@ "number-is-nan": { "version": "1.0.1", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "object-assign": { "version": "4.1.1", @@ -3101,6 +3114,7 @@ "version": "1.4.0", "bundled": true, "dev": true, + "optional": true, "requires": { "wrappy": "1" } @@ -3186,7 +3200,8 @@ "safe-buffer": { "version": "5.1.1", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "safer-buffer": { "version": "2.1.2", @@ -3222,6 +3237,7 @@ "version": "1.0.2", "bundled": true, "dev": true, + "optional": true, "requires": { "code-point-at": "^1.0.0", "is-fullwidth-code-point": "^1.0.0", @@ -3241,6 +3257,7 @@ "version": "3.0.1", "bundled": true, "dev": true, + "optional": true, "requires": { "ansi-regex": "^2.0.0" } @@ -3284,12 +3301,14 @@ "wrappy": { "version": "1.0.2", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "yallist": { "version": "3.0.2", "bundled": true, - "dev": true + "dev": true, + "optional": true } } },