@knight-lab/timelinejs 3.9.6 → 3.9.7

package/eleventy/node_modules/@11ty/lodash-custom/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@11ty/lodash-custom",
+  "version": "4.17.21",
+  "description": "A custom, focused build of lodash exclusively for use internally in Eleventy.",
+  "main": "lodash.custom.js",
+  "scripts": {
+    "build": "npx lodash exports=node include=get,set,chunk && rm lodash.custom.min.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/11ty"
+  },
+  "author": {
+    "name": "Zach Leatherman",
+    "email": "zachleatherman@gmail.com",
+    "url": "https://zachleat.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/11ty/lodash-custom.git"
+  },
+  "bugs": "https://github.com/11ty/lodash-custom/issues",
+  "homepage": "https://github.com/11ty/lodash-custom/",
+  "devDependencies": {
+    "ava": "^5.2.0",
+    "lodash-cli": "^4.17.5"
+  },
+  "overrides": {
+    "lodash": "4.17.21"
+  }
+}

package/eleventy/node_modules/@11ty/posthtml-urls/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Steven Vachon
+
+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/eleventy/node_modules/@11ty/posthtml-urls/README.md

@@ -0,0 +1,48 @@
+# `@11ty/posthtml-urls`
+
+PostHTML plugin for transforming URLs. This is a fork of [`posthtml/posthtml-urls`](https://github.com/posthtml/posthtml-urls).
+
+
+## Installation
+
+[Node.js](http://nodejs.org) `>= 6` is required. To install, type this at the command line:
+
+```shell
+npm install @11ty/posthtml-urls
+```
+
+
+## Usage
+
+```js
+const posthtml = require('posthtml');
+const urls = require('@11ty/posthtml-urls');
+
+const options = {
+  eachURL: (url, attr, tagName) => `http://domain.com/${url}`
+};
+
+posthtml()
+  .use( urls(options) )
+  .process('<a href="link.html">link</a>')
+  .then(result => console.log(result.html));
+//-> <a href="http://domain.com/link.html">link</a>
+```
+
+
+## Options
+
+### `eachURL`
+Type: `Function`
+Default value: `undefined`
+A callback function ran for each URL value found. You can return either a synchronous value or a `Promise`.
+
+### `filter`
+Type: `Object`
+Default value: [`{…}`](https://github.com/posthtml/posthtml-urls/blob/master/lib/defaultOptions.js)
+The elements and attributes for which to search. An attribute value can optionally be a function, for deeper filtering.
+
+
+## FAQ
+1. **How can I filter `<style>` elements and `style` attributes?**
+Use [posthtml-postcss](https://npmjs.com/posthtml-postcss) and [postcss-url](https://npmjs.com/postcss-url).

package/eleventy/node_modules/@11ty/posthtml-urls/lib/defaultOptions.js

@@ -0,0 +1,37 @@
+"use strict";
+const HTTP_EQUIV = "http-equiv";
+const REFRESH = "refresh";
+
+const isHttpEquiv = ({ attrs }) => {
+	return attrs && (HTTP_EQUIV in attrs) && attrs[HTTP_EQUIV].toLowerCase() === REFRESH;
+};
+
+// Fork: pruned some deprecated tag/attribute combos here.
+const DEFAULT_OPTIONS = {
+	filter: {
+		a: { href: true, ping: true },
+		area: { href: true, ping: true },
+		audio: { src: true },
+		base: { href: true },
+		blockquote: { cite: true },
+		button: { formaction: true },
+		del: { cite: true },
+		embed: { src: true },
+		form: { action: true },
+		iframe: { src: true },
+		img: { src: true, srcset: true },
+		input: { formaction: true, src: true },
+		ins: { cite: true },
+		link: { href: true },
+		meta: { content: isHttpEquiv },
+		object: { data: true },
+		q: { cite: true },
+		script: { src: true },
+		source: { src: true, srcset: true },
+		track: { src: true },
+		// video does not yet have srcset: https://scottjehl.com/posts/using-responsive-video/
+		video: { poster: true, src: true },
+	},
+};
+
+module.exports = DEFAULT_OPTIONS;

package/eleventy/node_modules/@11ty/posthtml-urls/lib/index.js

@@ -0,0 +1,142 @@
+"use strict";
+const DEFAULT_OPTIONS = require("./defaultOptions");
+const evaluateValue = require("evaluate-value");
+const list2Array = require("list-to-array");
+const parseMetaRefresh = require("http-equiv-refresh");
+const parseSrcset = require("parse-srcset");
+
+const CONTENT_ATTR = "content";
+const PING_ATTR = "ping";
+const SRCSET_ATTR = "srcset";
+
+const DELIMITER = ",";
+const EMPTY_STRING = "";
+const EMPTY_TAG_GROUP = Object.freeze({});
+const FUNCTION_TYPE = "function";
+const PRETTY_DELIMITER = ", ";
+
+
+
+const plugin = options =>
+{
+	const {eachURL, filter} = Object.assign({}, DEFAULT_OPTIONS, options);
+
+	if (typeof eachURL !== FUNCTION_TYPE)
+	{
+		throw new TypeError("eachURL option must be a function");
+	}
+
+	// const tagMatchers = Object.keys(filter).map(tagName => ({ tag: tagName }));
+
+	// Called by PostHTML
+	return tree =>
+	{
+		const promises = [];
+
+		tree.walk(node =>
+		// tree.match(tagMatchers, (node) =>
+		{
+			if (node.attrs === undefined) {
+				return node;
+			}
+
+			const tagGroup = filter[node.tag] || EMPTY_TAG_GROUP;
+
+			Object.keys(node.attrs).forEach(attrName =>
+			{
+				const isAcceptedTagAttr = attrName in tagGroup && evaluateValue(tagGroup[attrName], node, attrName);
+
+				if (isAcceptedTagAttr)
+				{
+					switch (attrName)
+					{
+						case CONTENT_ATTR:
+						{
+							promises.push( transformMetaRefresh(node, attrName, eachURL) );
+							break;
+						}
+						case PING_ATTR:
+						{
+							promises.push( transformCommaSeparated(node, attrName, eachURL) );
+							break;
+						}
+						case SRCSET_ATTR:
+						{
+							promises.push( transformSrcset(node, attrName, eachURL) );
+							break;
+						}
+						default:
+						{
+							promises.push( transformDefault(node, attrName, eachURL) );
+						}
+					}
+				}
+			});
+
+			return node;
+		});
+
+		return Promise.all(promises).then(() => tree);
+	};
+};
+
+
+
+const transformCommaSeparated = ({attrs, tag}, attrName, transformer) =>
+{
+	const urls = list2Array( attrs[attrName], DELIMITER );
+
+	if (urls.length > 0)
+	{
+		const promises = urls.map(value => Promise.resolve( transformer(value, attrName, tag) ));
+
+		return Promise.all(promises).then(newUrls => attrs[attrName] = newUrls.join(PRETTY_DELIMITER));
+	}
+};
+
+
+
+const transformDefault = ({attrs, tag}, attrName, transformer) =>
+{
+	return Promise.resolve( transformer( attrs[attrName], attrName, tag ) )
+	.then(newUrl => attrs[attrName] = newUrl);
+};
+
+
+
+const transformMetaRefresh = ({attrs, tag}, attrName, transformer) =>
+{
+	const {timeout, url} = parseMetaRefresh( attrs[attrName] );
+
+	if (timeout !== null)
+	{
+		return Promise.resolve( transformer(url || "", attrName, tag) )
+		.then(newUrl => attrs[attrName] = `${timeout}; url=${newUrl}`);
+	}
+};
+
+
+
+const transformSrcset = ({attrs, tag}, attrName, transformer) =>
+{
+	const values = parseSrcset( attrs[attrName] );
+
+	if (values.length > 0)
+	{
+		const promises = values.map(({d, h, url, w}) => Promise.resolve( transformer(url, attrName, tag) )
+		.then(newUrl =>
+		{
+			d = d !== undefined ? ` ${d}x` : EMPTY_STRING;
+			h = h !== undefined ? ` ${h}h` : EMPTY_STRING;
+			w = w !== undefined ? ` ${w}w` : EMPTY_STRING;
+
+			return `${newUrl}${w}${h}${d}`;
+		}));
+
+		return Promise.all(promises).then(newValues => attrs[attrName] = newValues.join(PRETTY_DELIMITER));
+	}
+};
+
+
+
+module.exports = plugin;

package/eleventy/node_modules/@11ty/posthtml-urls/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@11ty/posthtml-urls",
+  "version": "1.0.1",
+  "description": "PostHTML plugin for transforming URLs. A fork of posthtml/posthtml-urls.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib",
+  "license": "MIT",
+  "author": "Zach Leatherman <null@zachleat.com> (https://zachleat.com/)",
+  "contributors": ["Steven Vachon <contact@svachon.com> (https://svachon.com)"],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/11ty/eleventy-posthtml-urls.git"
+  },
+  "dependencies": {
+    "evaluate-value": "^2.0.0",
+    "http-equiv-refresh": "^2.0.1",
+    "list-to-array": "^1.1.0",
+    "parse-srcset": "^1.0.2"
+  },
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "coveralls": "^3.0.6",
+    "html-tags": "^3.1.1",
+    "mocha": "^6.2.0",
+    "nyc": "^14.1.1",
+    "posthtml": "~0.16.6"
+  },
+  "engines": {
+    "node": ">= 6"
+  },
+  "scripts": {
+    "ci": "npm test && nyc report --reporter=text-lcov | coveralls",
+    "posttest": "nyc report --reporter=text-summary --reporter=html",
+    "prepublishOnly": "npm test",
+    "test": "nyc --silent mocha test.js --bail --check-leaks"
+  },
+  "files": [
+    "lib"
+  ],
+  "keywords": [
+    "posthtml",
+    "posthtml-plugin",
+    "url"
+  ]
+}

package/eleventy/node_modules/@11ty/recursive-copy/README.md

@@ -0,0 +1,198 @@
+# `@11ty/recursive-copy`
+
+A temporary fork of [`timkendrick/recursive-copy`](https://github.com/timkendrick/recursive-copy) to satisfy https://github.com/11ty/eleventy/issues/3299 as Eleventy slowly [moves to use Node native API `fs.cp`](https://github.com/11ty/eleventy/issues/3360).
+
+> Simple, flexible file copy utility
+
+## Features
+
+- Recursively copy whole directory hierarchies
+- Choose which files are copied by passing a filter function, regular expression or glob
+- Rename files dynamically, including changing the output path
+- Transform file contents using streams
+- Choose whether to overwrite existing files
+- Choose whether to copy system files
+- Filters out [junk](https://www.npmjs.com/package/junk) files by default
+- Uses [graceful-fs](https://www.npmjs.com/package/graceful-fs) and [mkdirp](https://www.npmjs.com/package/mkdirp) to avoid filesystem errors
+- Emits start, finish and error events for each file that is processed
+- Optional promise-based interface
+
+## Examples
+
+#### Node-style callback interface
+
+```javascript
+var copy = require('@11ty/recursive-copy');
+
+copy('src', 'dest', function(error, results) {
+	if (error) {
+		console.error('Copy failed: ' + error);
+	} else {
+		console.info('Copied ' + results.length + ' files');
+	}
+});
+```
+
+#### Promise interface
+
+```javascript
+var copy = require('@11ty/recursive-copy');
+
+copy('src', 'dest')
+	.then(function(results) {
+		console.info('Copied ' + results.length + ' files');
+	})
+	.catch(function(error) {
+		console.error('Copy failed: ' + error);
+	});
+```
+
+#### ES2015+ usage
+
+```javascript
+import copy from '@11ty/recursive-copy';
+
+try {
+	const results = await copy('src', 'dest');
+	console.info('Copied ' + results.length + ' files');
+} catch (error) {
+	console.error('Copy failed: ' + error);
+}
+```
+
+#### Advanced options
+
+```javascript
+var copy = require('@11ty/recursive-copy');
+
+var path = require('path');
+var through = require('through2');
+
+var options = {
+	overwrite: true,
+	expand: true,
+	dot: true,
+	junk: true,
+	filter: [
+		'**/*',
+		'!.htpasswd'
+	],
+	rename: function(filePath) {
+		return filePath + '.orig';
+	},
+	transform: function(src, dest, stats) {
+		if (path.extname(src) !== '.txt') { return null; }
+		return through(function(chunk, enc, done)  {
+			var output = chunk.toString().toUpperCase();
+			done(null, output);
+		});
+	}
+};
+
+copy('src', 'dest', options)
+	.on(copy.events.COPY_FILE_START, function(copyOperation) {
+		console.info('Copying file ' + copyOperation.src + '...');
+	})
+	.on(copy.events.COPY_FILE_COMPLETE, function(copyOperation) {
+		console.info('Copied to ' + copyOperation.dest);
+	})
+	.on(copy.events.ERROR, function(error, copyOperation) {
+		console.error('Unable to copy ' + copyOperation.dest);
+	})
+	.then(function(results) {
+		console.info(results.length + ' file(s) copied');
+	})
+	.catch(function(error) {
+		return console.error('Copy failed: ' + error);
+	});
+```
+
+
+## Usage
+
+### `copy(src, dest, [options], [callback])`
+
+Recursively copy files and folders from `src` to `dest`
+
+#### Arguments:
+
+| Name | Type | Required | Default | Description |
+| ---- | ---- | -------- | ------- | ----------- |
+| `src` | `string` | Yes | N/A | Source file/folder path |
+| `dest` | `string` | Yes | N/A | Destination file/folder path |
+| `options.overwrite` | `boolean` | No | `false` | Whether to overwrite destination files |
+| `options.expand` | `boolean` | No | `false` | Whether to expand symbolic links |
+| `options.dot` | `boolean` | No | `false` | Whether to copy files beginning with a `.` |
+| `options.junk` | `boolean` | No | `false` | Whether to copy OS junk files (e.g. `.DS_Store`, `Thumbs.db`) |
+| `options.filter` | `function`, `RegExp`, `string`, `array` | No | `null` | Filter function / regular expression / glob that determines which files to copy (uses [maximatch](https://www.npmjs.com/package/maximatch)) |
+| `options.rename` | `function` | No | `null` | Function that maps source paths to destination paths |
+| `options.transform` | `function` | No | `null` | Function that returns a transform stream used to modify file contents |
+| `options.results` | `boolean` | No | `true` | Whether to return an array of copy results |
+| `options.concurrency` | `number` | No | `255` | Maximum number of simultaneous copy operations |
+| `options.debug` | `boolean` | No | `false` | Whether to log debug information |
+| `callback` | `function` | No | `null` | Callback, invoked on success/failure |
+
+
+#### Returns:
+
+`Promise<Array>` Promise, fulfilled with array of copy results:
+
+```json
+[
+	{
+		"src": "/path/to/src",
+		"dest": "/path/to/dest",
+		"stats": <Stats>
+	},
+	{
+		"src": "/path/to/src/file.txt",
+		"dest": "/path/to/dest/file.txt",
+		"stats": <Stats>
+	},
+	{
+		"src": "/path/to/src/subfolder",
+		"dest": "/path/to/dest/subfolder",
+		"stats": <Stats>
+	},
+	{
+		"src": "/path/to/src/subfolder/nested.txt",
+		"dest": "/path/to/dest/subfolder/nested.txt",
+		"stats": <Stats>
+	}
+]
+```
+
+## Events
+
+The value returned by the `copy` function implements the `EventEmitter` interface, and emits the following events:
+
+| Event | Handler signature |
+| ----- | ----------------- |
+| `copy.events.ERROR` | `function(error, ErrorInfo)` |
+| `copy.events.COMPLETE` | `function(Array<CopyOperation>)` |
+| `copy.events.CREATE_DIRECTORY_START` | `function(CopyOperation)` |
+| `copy.events.CREATE_DIRECTORY_ERROR` | `function(error, CopyOperation)` |
+| `copy.events.CREATE_DIRECTORY_COMPLETE` | `function(CopyOperation)` |
+| `copy.events.CREATE_SYMLINK_START` | `function(CopyOperation)` |
+| `copy.events.CREATE_SYMLINK_ERROR` | `function(error, CopyOperation)` |
+| `copy.events.CREATE_SYMLINK_COMPLETE` | `function(CopyOperation)` |
+| `copy.events.COPY_FILE_START` | `function(CopyOperation)` |
+| `copy.events.COPY_FILE_ERROR` | `function(error, CopyOperation)` |
+| `copy.events.COPY_FILE_COMPLETE` | `function(CopyOperation)` |
+
+...where the types referred to in the handler signature are as follows:
+
+### `ErrorInfo`
+
+| Property | Type | Description |
+| -------- | ---- | ----------- |
+| `src` | `string` | Source path of the file/folder/symlink that failed to copy |
+| `dest` | `string` | Destination path of the file/folder/symlink that failed to copy |
+
+### `CopyOperation`
+
+| Property | Type | Description |
+| -------- | ---- | ----------- |
+| `src` | `string` | Source path of the relevant file/folder/symlink |
+| `dest` | `string` | Destination path of the relevant file/folder/symlink |
+| `stats ` | `fs.Stats` | Stats for the relevant file/folder/symlink |

package/eleventy/node_modules/@11ty/recursive-copy/index.d.ts

@@ -0,0 +1,117 @@
+import { Stats } from 'fs';
+import { Stream } from 'stream';
+
+interface Options {
+	/**
+	 * Whether to overwrite destination files.
+	 */
+	overwrite?: boolean;
+	/**
+	 * Whether to expand symbolic links.
+	 */
+	expand?: boolean;
+	/**
+	 * Whether to copy files beginning with a `.`
+	 */
+	dot?: boolean;
+	/**
+	 * Whether to copy OS junk files (e.g. `.DS_Store`, `Thumbs.db`).
+	 */
+	junk?: boolean;
+	/**
+	 * Filter function / regular expression / glob that determines which files to copy (uses maximatch).
+	 */
+	filter?: string | string[] | RegExp | ((path: string) => boolean);
+	/**
+	 * Function that maps source paths to destination paths.
+	 */
+	rename?: (path: string) => string;
+	/**
+	 * Function that returns a transform stream used to modify file contents.
+	 */
+	transform?: (src: string, dest: string, stats: Stats) => Stream | null | undefined;
+	/**
+	 * Whether to return an array of copy results.
+	 *
+	 * Defaults to true.
+	 */
+	results?: boolean;
+	/**
+	 * Maximum number of simultaneous copy operations.
+	 *
+	 * Defaults to 255.
+	 */
+	concurrency?: number;
+	/**
+	 * Whether to log debug information.
+	 */
+	debug?: boolean;
+}
+
+interface CopyFn {
+	(
+		source: string,
+		dest: string,
+		options?: Options,
+	): WithCopyEvents<Promise<Array<CopyOperation>>>;
+	(
+		source: string,
+		dest: string,
+		callback: (error: Error | null, results?: Array<CopyOperation>) => void,
+	): WithCopyEvents<{}>;
+	events: {
+		ERROR: CopyEventType.ERROR;
+		COMPLETE: CopyEventType.COMPLETE;
+		CREATE_DIRECTORY_START: CopyEventType.CREATE_DIRECTORY_START;
+		CREATE_DIRECTORY_ERROR: CopyEventType.CREATE_DIRECTORY_ERROR;
+		CREATE_DIRECTORY_COMPLETE: CopyEventType.CREATE_DIRECTORY_COMPLETE;
+		CREATE_SYMLINK_START: CopyEventType.CREATE_SYMLINK_START;
+		CREATE_SYMLINK_ERROR: CopyEventType.CREATE_SYMLINK_ERROR;
+		CREATE_SYMLINK_COMPLETE: CopyEventType.CREATE_SYMLINK_COMPLETE;
+		COPY_FILE_START: CopyEventType.COPY_FILE_START;
+		COPY_FILE_ERROR: CopyEventType.COPY_FILE_ERROR;
+		COPY_FILE_COMPLETE: CopyEventType.COPY_FILE_COMPLETE;
+	};
+}
+
+declare const copy: CopyFn;
+export default copy;
+
+export interface CopyErrorInfo {
+	src: string;
+	dest: string;
+}
+
+export interface CopyOperation {
+	src: string;
+	dest: string;
+	stats: Stats;
+}
+
+type WithCopyEvents<T> = T & {
+	on(event: CopyEventType.ERROR, callback: (error: Error, info: CopyErrorInfo) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.COMPLETE, callback: (info: Array<CopyOperation>) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.CREATE_DIRECTORY_START, callback: (info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.CREATE_DIRECTORY_ERROR, callback: (error: Error, info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.CREATE_DIRECTORY_COMPLETE, callback: (info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.CREATE_SYMLINK_START, callback: (info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.CREATE_SYMLINK_ERROR, callback: (error: Error, info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.CREATE_SYMLINK_COMPLETE, callback: (info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.COPY_FILE_START, callback: (info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.COPY_FILE_ERROR, callback: (error: Error, info: CopyOperation) => void): WithCopyEvents<T>;
+	on(event: CopyEventType.COPY_FILE_COMPLETE, callback: (info: CopyOperation) => void): WithCopyEvents<T>;
+}
+
+export enum CopyEventType {
+	ERROR = 'error',
+	COMPLETE = 'complete',
+	CREATE_DIRECTORY_START = 'createDirectoryStart',
+	CREATE_DIRECTORY_ERROR = 'createDirectoryError',
+	CREATE_DIRECTORY_COMPLETE = 'createDirectoryComplete',
+	CREATE_SYMLINK_START = 'createSymlinkStart',
+	CREATE_SYMLINK_ERROR = 'createSymlinkError',
+	CREATE_SYMLINK_COMPLETE = 'createSymlinkComplete',
+	COPY_FILE_START = 'copyFileStart',
+	COPY_FILE_ERROR = 'copyFileError',
+	COPY_FILE_COMPLETE = 'copyFileComplete',
+}

package/eleventy/node_modules/@11ty/recursive-copy/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/copy');