@flourish/sdk 4.2.1 → 4.2.2

package/my_template/node_modules/rollup-plugin-node-resolve/src/index.js

@@ -0,0 +1,358 @@
+import {dirname, extname, join, normalize, resolve, sep} from 'path';
+import builtinList from 'builtin-modules';
+import resolveId from 'resolve';
+import isModule from 'is-module';
+import fs from 'fs';
+import {createFilter} from 'rollup-pluginutils';
+import {peerDependencies} from '../package.json';
+
+const builtins = new Set(builtinList);
+
+const ES6_BROWSER_EMPTY = '\0node-resolve:empty.js';
+// It is important that .mjs occur before .js so that Rollup will interpret npm modules
+// which deploy both ESM .mjs and CommonJS .js files as ESM.
+const DEFAULT_EXTS = [ '.mjs', '.js', '.json', '.node' ];
+
+const existsAsync = file => new Promise(fulfil => fs.exists(file, fulfil));
+
+const readFileAsync = file => new Promise((fulfil, reject) => fs.readFile(file, (err, contents) => err ? reject(err) : fulfil(contents)));
+
+const realpathAsync = file => new Promise((fulfil, reject) => fs.realpath(file, (err, contents) => err ? reject(err) : fulfil(contents)));
+
+const statAsync = file => new Promise((fulfil, reject) => fs.stat(file, (err, contents) => err ? reject(err) : fulfil(contents)));
+
+const cache = fn => {
+	const cache = new Map();
+	const wrapped = (param, done) => {
+		if (cache.has(param) === false) {
+			cache.set(param, fn(param).catch(err => {
+				cache.delete(param);
+				throw err;
+			}));
+		}
+		return cache.get(param).then(result => done(null, result), done);
+	};
+	wrapped.clear = () => cache.clear();
+	return wrapped;
+};
+
+const ignoreENOENT = err => {
+	if (err.code === 'ENOENT') return false;
+	throw err;
+};
+
+const readFileCached = cache(readFileAsync);
+
+const isDirCached = cache(file => statAsync(file).then(stat => stat.isDirectory(), ignoreENOENT));
+
+const isFileCached = cache(file => statAsync(file).then(stat => stat.isFile(), ignoreENOENT));
+
+function getMainFields (options) {
+	let mainFields;
+	if (options.mainFields) {
+		if ('module' in options || 'main' in options || 'jsnext' in options) {
+			throw new Error(`node-resolve: do not use deprecated 'module', 'main', 'jsnext' options with 'mainFields'`);
+		}
+		mainFields = options.mainFields;
+	} else {
+		mainFields = [];
+		[['module', 'module', true], ['jsnext', 'jsnext:main', false], ['main', 'main', true]].forEach(([option, field, defaultIncluded]) => {
+			if (option in options) {
+				// eslint-disable-next-line no-console
+				console.warn(`node-resolve: setting options.${option} is deprecated, please override options.mainFields instead`);
+				if (options[option]) {
+					mainFields.push(field);
+				}
+			} else if (defaultIncluded) {
+				mainFields.push(field);
+			}
+		});
+	}
+	if (options.browser && mainFields.indexOf('browser') === -1) {
+		return ['browser'].concat(mainFields);
+	}
+	if ( !mainFields.length ) {
+		throw new Error( `Please ensure at least one 'mainFields' value is specified` );
+	}
+	return mainFields;
+}
+
+const alwaysNull = () => null;
+
+const resolveIdAsync = (file, opts) => new Promise((fulfil, reject) => resolveId(file, opts, (err, contents) => err ? reject(err) : fulfil(contents)));
+
+// Resolve module specifiers in order. Promise resolves to the first
+// module that resolves successfully, or the error that resulted from
+// the last attempted module resolution.
+function resolveImportSpecifiers (importSpecifierList, resolveOptions) {
+	let p = Promise.resolve();
+	for (let i = 0; i < importSpecifierList.length; i++) {
+		p = p.then(v => {
+			// if we've already resolved to something, just return it.
+			if (v) return v;
+
+			return resolveIdAsync(importSpecifierList[i], resolveOptions);
+		});
+
+		if (i < importSpecifierList.length - 1) {
+			// swallow MODULE_NOT_FOUND errors from all but the last resolution
+			p = p.catch(err => {
+				if (err.code !== 'MODULE_NOT_FOUND') {
+					throw err;
+				}
+			});
+		}
+	}
+
+	return p;
+}
+
+export default function nodeResolve ( options = {} ) {
+	const mainFields = getMainFields(options);
+	const useBrowserOverrides = mainFields.indexOf('browser') !== -1;
+	const dedupe = options.dedupe || [];
+	const isPreferBuiltinsSet = options.preferBuiltins === true || options.preferBuiltins === false;
+	const preferBuiltins = isPreferBuiltinsSet ? options.preferBuiltins : true;
+	const customResolveOptions = options.customResolveOptions || {};
+	const jail = options.jail;
+	const only = Array.isArray(options.only)
+		? options.only.map(o => o instanceof RegExp
+			? o
+			: new RegExp('^' + String(o).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&') + '$')
+		)
+		: null;
+	const browserMapCache = new Map();
+
+	if ( options.skip ) {
+		throw new Error( 'options.skip is no longer supported — you should use the main Rollup `external` option instead' );
+	}
+
+	const extensions = options.extensions || DEFAULT_EXTS;
+	const packageInfoCache = new Map();
+
+	const shouldDedupe = typeof dedupe === 'function'
+		? dedupe
+		: importee => dedupe.includes(importee);
+
+	function getCachedPackageInfo (pkg, pkgPath) {
+		if (packageInfoCache.has(pkgPath)) {
+			return packageInfoCache.get(pkgPath);
+		}
+		const pkgRoot = dirname( pkgPath );
+
+		let overriddenMain = false;
+		for ( let i = 0; i < mainFields.length; i++ ) {
+			const field = mainFields[i];
+			if ( typeof pkg[ field ] === 'string' ) {
+				pkg[ 'main' ] = pkg[ field ];
+				overriddenMain = true;
+				break;
+			}
+		}
+
+		const packageInfo = {
+			cachedPkg: pkg,
+			hasModuleSideEffects: alwaysNull,
+			hasPackageEntry: overriddenMain !== false || mainFields.indexOf( 'main' ) !== -1,
+			packageBrowserField: useBrowserOverrides && typeof pkg[ 'browser' ] === 'object' &&
+				Object.keys(pkg[ 'browser' ]).reduce((browser, key) => {
+					let resolved = pkg[ 'browser' ][ key ];
+					if (resolved && resolved[0] === '.') {
+						resolved = resolve( pkgRoot, resolved );
+					}
+					browser[ key ] = resolved;
+					if ( key[0] === '.' ) {
+						const absoluteKey = resolve( pkgRoot, key );
+						browser[ absoluteKey ] = resolved;
+						if ( !extname(key) ) {
+							extensions.reduce( ( browser, ext ) => {
+								browser[ absoluteKey + ext ] = browser[ key ];
+								return browser;
+							}, browser );
+						}
+					}
+					return browser;
+				}, {})
+		};
+
+		const packageSideEffects = pkg['sideEffects'];
+		if (typeof packageSideEffects === 'boolean') {
+			packageInfo.hasModuleSideEffects = () => packageSideEffects;
+		} else if (Array.isArray(packageSideEffects)) {
+			packageInfo.hasModuleSideEffects = createFilter(packageSideEffects, null, {resolve: pkgRoot});
+		}
+
+		packageInfoCache.set(pkgPath, packageInfo);
+		return packageInfo;
+	}
+
+	let preserveSymlinks;
+
+	return {
+		name: 'node-resolve',
+
+		buildStart ( options ) {
+			preserveSymlinks = options.preserveSymlinks;
+			const [major, minor] = this.meta.rollupVersion.split('.').map(Number);
+			const minVersion = peerDependencies.rollup.slice(2);
+			const [minMajor, minMinor] = minVersion.split('.').map(Number);
+			if (major < minMajor || (major === minMajor && minor < minMinor)) {
+				this.error(
+					`Insufficient Rollup version: "rollup-plugin-node-resolve" requires at least rollup@${minVersion} but found rollup@${
+						this.meta.rollupVersion
+					}.`
+				);
+			}
+		},
+
+		generateBundle () {
+			readFileCached.clear();
+			isFileCached.clear();
+			isDirCached.clear();
+		},
+
+		resolveId ( importee, importer ) {
+			if (importee === ES6_BROWSER_EMPTY) {
+				return importee;
+			}
+
+			if ( /\0/.test( importee ) ) return null; // ignore IDs with null character, these belong to other plugins
+
+			const basedir = importer ? dirname( importer ) : process.cwd();
+
+			if (shouldDedupe(importee)) {
+				importee = join(process.cwd(), 'node_modules', importee);
+			}
+
+			// https://github.com/defunctzombie/package-browser-field-spec
+			const browser = browserMapCache.get(importer);
+			if (useBrowserOverrides && browser) {
+				const resolvedImportee = resolve( basedir, importee );
+				if (browser[importee] === false || browser[resolvedImportee] === false) {
+					return ES6_BROWSER_EMPTY;
+				}
+				const browserImportee = browser[importee] || browser[resolvedImportee] || browser[resolvedImportee + '.js'] || browser[resolvedImportee + '.json'];
+				if (browserImportee) {
+					importee = browserImportee;
+				}
+			}
+
+			const parts = importee.split( /[/\\]/ );
+			let id = parts.shift();
+
+			if ( id[0] === '@' && parts.length > 0 ) {
+				// scoped packages
+				id += `/${parts.shift()}`;
+			} else if ( id[0] === '.' ) {
+				// an import relative to the parent dir of the importer
+				id = resolve( basedir, importee );
+			}
+
+			if (only && !only.some(pattern => pattern.test(id))) return null;
+
+			let hasModuleSideEffects = alwaysNull;
+			let hasPackageEntry = true;
+			let packageBrowserField = false;
+
+			const resolveOptions = {
+				basedir,
+				packageFilter ( pkg, pkgPath ) {
+					let cachedPkg;
+					({cachedPkg, hasModuleSideEffects, hasPackageEntry, packageBrowserField} =
+						getCachedPackageInfo(pkg, pkgPath));
+					return cachedPkg;
+				},
+				readFile: readFileCached,
+				isFile: isFileCached,
+				isDirectory: isDirCached,
+				extensions: extensions
+			};
+
+			if (preserveSymlinks !== undefined) {
+				resolveOptions.preserveSymlinks = preserveSymlinks;
+			}
+
+			const importSpecifierList = [];
+
+			if (importer === undefined && !importee[0].match(/^\.?\.?\//)) {
+				// For module graph roots (i.e. when importer is undefined), we
+				// need to handle 'path fragments` like `foo/bar` that are commonly
+				// found in rollup config files. If importee doesn't look like a
+				// relative or absolute path, we make it relative and attempt to
+				// resolve it. If we don't find anything, we try resolving it as we
+				// got it.
+				importSpecifierList.push('./' + importee);
+			}
+
+			const importeeIsBuiltin = builtins.has(importee);
+
+			if (importeeIsBuiltin && (!preferBuiltins || !isPreferBuiltinsSet)) {
+				// The `resolve` library will not resolve packages with the same
+				// name as a node built-in module. If we're resolving something
+				// that's a builtin, and we don't prefer to find built-ins, we
+				// first try to look up a local module with that name. If we don't
+				// find anything, we resolve the builtin which just returns back
+				// the built-in's name.
+				importSpecifierList.push(importee + '/');
+			}
+
+			importSpecifierList.push(importee);
+
+			return resolveImportSpecifiers(
+				importSpecifierList,
+				Object.assign(resolveOptions, customResolveOptions)
+			)
+				.then(resolved => {
+					if ( resolved && packageBrowserField ) {
+						if ( Object.prototype.hasOwnProperty.call(packageBrowserField,resolved) ) {
+							if (!packageBrowserField[resolved]) {
+								browserMapCache.set(resolved, packageBrowserField);
+								return ES6_BROWSER_EMPTY;
+							}
+							resolved = packageBrowserField[ resolved ];
+						}
+						browserMapCache.set(resolved, packageBrowserField);
+					}
+
+					if ( hasPackageEntry && !preserveSymlinks && resolved ) {
+						return existsAsync( resolved )
+							.then(exists => exists ? realpathAsync( resolved ) : resolved);
+					}
+					return resolved;
+				})
+				.then(resolved => {
+					if ( hasPackageEntry ) {
+						if (builtins.has(resolved) && preferBuiltins && isPreferBuiltinsSet) {
+							return null;
+						} else if (importeeIsBuiltin && preferBuiltins) {
+							if ( !isPreferBuiltinsSet ) {
+								this.warn(
+									`preferring built-in module '${importee}' over local alternative ` +
+									`at '${resolved}', pass 'preferBuiltins: false' to disable this ` +
+									`behavior or 'preferBuiltins: true' to disable this warning`
+								);
+							}
+							return null;
+						} else if ( jail && resolved.indexOf( normalize( jail.trim( sep ) ) ) !== 0 ) {
+							return null;
+						}
+					}
+
+					if ( resolved && options.modulesOnly ) {
+						return readFileAsync( resolved, 'utf-8')
+							.then(code => isModule( code ) ? {id: resolved, moduleSideEffects: hasModuleSideEffects(resolved)} : null);
+					} else {
+						return {id: resolved, moduleSideEffects: hasModuleSideEffects(resolved)};
+					}
+				})
+				.catch(() => null);
+		},
+
+		load ( importee ) {
+			if ( importee === ES6_BROWSER_EMPTY ) {
+				return 'export default {};';
+			}
+			return null;
+		},
+	};
+}

package/my_template/node_modules/rollup-plugin-uglify/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2016 Bogdan Chadkin <trysound@yandex.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/my_template/node_modules/rollup-plugin-uglify/README.md

@@ -0,0 +1,84 @@
+# rollup-plugin-uglify [![Travis Build Status][travis-img]][travis]
+
+[travis-img]: https://travis-ci.org/TrySound/rollup-plugin-uglify.svg
+[travis]: https://travis-ci.org/TrySound/rollup-plugin-uglify
+
+[Rollup](https://github.com/rollup/rollup) plugin to minify generated bundle. Uses [UglifyJS](https://github.com/mishoo/UglifyJS2) under the hood. There are a few improvements over native uglify:
+
+* uglify is run in worker for every chunk
+* errors are displayed with [babel code frame](https://babeljs.io/docs/en/next/babel-code-frame.html)
+
+_Note: uglify-js is able to transpile only es5 syntax. If you want to transpile es6+ syntax use [terser](https://github.com/TrySound/rollup-plugin-terser) instead_
+
+## Install
+
+```sh
+yarn add rollup-plugin-uglify --dev
+```
+
+*Note: this package requires rollup@0.66 and higher*
+
+## Usage
+
+```js
+import { rollup } from "rollup";
+import { uglify } from "rollup-plugin-uglify";
+
+rollup({
+  input: "main.js",
+  plugins: [uglify()]
+});
+```
+
+## Options
+
+```js
+uglify(options);
+```
+
+`options` - [uglifyJS API options](https://github.com/mishoo/UglifyJS2/blob/master/README.md#minify-options)
+
+`options.sourcemap: boolean`
+
+Generates source maps and passes them to rollup. Defaults to `true`.
+
+`options.numWorkers: number`
+
+Amount of workers to spawn. Defaults to the number of CPUs minus 1.
+
+
+## Examples
+
+### Comments
+
+If you'd like to preserve comments (for licensing for example), then you can specify a function to do this like so:
+
+```js
+uglify({
+  output: {
+    comments: function(node, comment) {
+      if (comment.type === "comment2") {
+        // multiline comment
+        return /@preserve|@license|@cc_on/i.test(comment.value);
+      }
+      return false;
+    }
+  }
+});
+```
+
+Alternatively, you can also choose to keep all comments (e.g. if a licensing header has already been prepended by a previous rollup plugin):
+
+```js
+uglify({
+  output: {
+    comments: "all"
+  }
+});
+```
+
+See [UglifyJS documentation](https://github.com/mishoo/UglifyJS2/blob/master/README.md) for further reference.
+
+# License
+
+MIT © [Bogdan Chadkin](mailto:trysound@yandex.ru)

package/my_template/node_modules/rollup-plugin-uglify/index.js

@@ -0,0 +1,51 @@
+const { codeFrameColumns } = require("@babel/code-frame");
+const Worker = require("jest-worker").default;
+const serialize = require("serialize-javascript");
+
+function uglify(userOptions = {}) {
+  if (userOptions.sourceMap != null) {
+    throw Error("sourceMap option is removed, use sourcemap instead");
+  }
+
+  const normalizedOptions = Object.assign({}, userOptions, {
+    sourceMap: userOptions.sourcemap !== false
+  });
+
+  ["sourcemap"].forEach(key => {
+    if (normalizedOptions.hasOwnProperty(key)) {
+      delete normalizedOptions[key];
+    }
+  });
+
+  const minifierOptions = serialize(normalizedOptions);
+
+  return {
+    name: "uglify",
+
+    renderStart() {
+      this.worker = new Worker(require.resolve("./transform.js"), {
+        numWorkers: userOptions.numWorkers
+      });
+    },
+
+    renderChunk(code) {
+      return this.worker.transform(code, minifierOptions).catch(error => {
+        const { message, line, col: column } = error;
+        console.error(
+          codeFrameColumns(code, { start: { line, column } }, { message })
+        );
+        throw error;
+      });
+    },
+
+    generateBundle() {
+      this.worker.end();
+    },
+
+    renderError() {
+      this.worker.end();
+    }
+  };
+}
+
+exports.uglify = uglify;

package/my_template/node_modules/rollup-plugin-uglify/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "rollup-plugin-uglify",
+  "version": "6.0.4",
+  "description": "Rollup plugin to minify generated bundle",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "transform.js"
+  ],
+  "scripts": {
+    "test": "jest --runInBand",
+    "prepublish": "yarn test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TrySound/rollup-plugin-uglify.git"
+  },
+  "keywords": [
+    "rollup",
+    "rollup-plugin",
+    "uglify",
+    "minify"
+  ],
+  "author": "Bogdan Chadkin <trysound@yandex.ru>",
+  "license": "MIT",
+  "dependencies": {
+    "@babel/code-frame": "^7.0.0",
+    "jest-worker": "^24.0.0",
+    "serialize-javascript": "^2.1.2",
+    "uglify-js": "^3.4.9"
+  },
+  "peerDependencies": {
+    "rollup": ">=0.66.0 <2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.2.2",
+    "@babel/preset-env": "^7.3.1",
+    "babel-jest": "^24.0.0",
+    "jest": "^24.0.0",
+    "prettier": "^1.16.1",
+    "rollup": "^1.27.10"
+  }
+}

package/my_template/node_modules/rollup-plugin-uglify/transform.js

@@ -0,0 +1,13 @@
+const { minify } = require("uglify-js");
+
+const transform = (code, optionsString) => {
+  const options = eval(`(${optionsString})`)
+  const result = minify(code, options);
+  if (result.error) {
+    throw result.error;
+  } else {
+    return result;
+  }
+};
+
+exports.transform = transform;

package/my_template/node_modules/rollup-pluginutils/CHANGELOG.md

@@ -0,0 +1,125 @@
+# rollup-pluginutils changelog
+
+## 2.8.2
+*2019-09-13*
+* Handle optional catch parameter in attachScopes ([#70](https://github.com/rollup/rollup-pluginutils/pulls/70))
+
+## 2.8.1
+*2019-06-04*
+* Support serialization of many edge cases ([#64](https://github.com/rollup/rollup-pluginutils/issues/64))
+
+## 2.8.0
+*2019-05-30*
+* Bundle updated micromatch dependency ([#60](https://github.com/rollup/rollup-pluginutils/issues/60))
+
+## 2.7.1
+*2019-05-17*
+* Do not ignore files with a leading "." in createFilter ([#62](https://github.com/rollup/rollup-pluginutils/issues/62))
+
+## 2.7.0
+*2019-05-15*
+* Add `resolve` option to createFilter ([#59](https://github.com/rollup/rollup-pluginutils/issues/59))
+
+## 2.6.0
+*2019-04-04*
+* Add `extractAssignedNames` ([#59](https://github.com/rollup/rollup-pluginutils/issues/59))
+* Provide dedicated TypeScript typings file ([#58](https://github.com/rollup/rollup-pluginutils/issues/58))
+
+## 2.5.0
+*2019-03-18*
+* Generalize dataToEsm type ([#55](https://github.com/rollup/rollup-pluginutils/issues/55))
+* Handle empty keys in dataToEsm ([#56](https://github.com/rollup/rollup-pluginutils/issues/56))
+
+## 2.4.1
+*2019-02-16*
+* Remove unnecessary dependency
+
+## 2.4.0
+*2019-02-16*
+Update dependencies to solve micromatch vulnerability ([#53](https://github.com/rollup/rollup-pluginutils/issues/53))
+
+## 2.3.3
+*2018-09-19*
+* Revert micromatch update ([#43](https://github.com/rollup/rollup-pluginutils/issues/43))
+
+## 2.3.2
+*2018-09-18*
+* Bumb micromatch dependency ([#36](https://github.com/rollup/rollup-pluginutils/issues/36))
+* Bumb dependencies ([#41](https://github.com/rollup/rollup-pluginutils/issues/41))
+* Split up tests ([#40](https://github.com/rollup/rollup-pluginutils/issues/40))
+
+## 2.3.1
+*2018-08-06*
+* Fixed ObjectPattern scope in attachScopes to recognise { ...rest } syntax ([#37](https://github.com/rollup/rollup-pluginutils/issues/37))
+
+## 2.3.0
+*2018-05-21*
+* Add option to not generate named exports ([#32](https://github.com/rollup/rollup-pluginutils/issues/32))
+
+## 2.2.1
+*2018-05-21*
+* Support `null` serialization ([#34](https://github.com/rollup/rollup-pluginutils/issues/34))
+
+## 2.2.0
+*2018-05-11*
+* Improve white-space handling in `dataToEsm` and add `prepare` script ([#31](https://github.com/rollup/rollup-pluginutils/issues/31))
+
+## 2.1.1
+*2018-05-09*
+* Update dependencies
+
+## 2.1.0
+*2018-05-08*
+* Add `dataToEsm` helper to create named exports from objects ([#29](https://github.com/rollup/rollup-pluginutils/issues/29))
+* Support literal keys in object patterns ([#27](https://github.com/rollup/rollup-pluginutils/issues/27))
+* Support function declarations without id in `attachScopes` ([#28](https://github.com/rollup/rollup-pluginutils/issues/28))
+
+## 2.0.1
+*2017-01-03*
+* Don't add extension to file with trailing dot ([#14](https://github.com/rollup/rollup-pluginutils/issues/14))
+
+## 2.0.0
+*2017-01-03*
+* Use `micromatch` instead of `minimatch` ([#19](https://github.com/rollup/rollup-pluginutils/issues/19))
+* Allow `createFilter` to take regexes ([#5](https://github.com/rollup/rollup-pluginutils/issues/5))
+
+## 1.5.2
+*2016-08-29*
+* Treat `arguments` as a reserved word ([#10](https://github.com/rollup/rollup-pluginutils/issues/10))
+
+## 1.5.1
+*2016-06-24*
+* Add all declarators in a var declaration to scope, not just the first
+
+## 1.5.0
+*2016-06-07*
+* Exclude IDs with null character (`\0`)
+
+## 1.4.0
+*2016-06-07*
+* Workaround minimatch issue ([#6](https://github.com/rollup/rollup-pluginutils/pull/6))
+* Exclude non-string IDs in `createFilter`
+
+## 1.3.1
+*2015-12-16*
+* Build with Rollup directly, rather than via Gobble
+
+## 1.3.0
+*2015-12-16*
+* Use correct path separator on Windows
+
+## 1.2.0
+*2015-11-02*
+* Add `attachScopes` and `makeLegalIdentifier`
+
+## 1.1.0
+2015-10-24*
+* Add `addExtension` function
+
+## 1.0.1
+*2015-10-24*
+* Include dist files in package
+
+## 1.0.0
+*2015-10-24*
+* First release