🎉 initiate project *astro_rewrite*

2023-07-19 21:31:30 +02:00 · 2023-07-19 21:31:30 +02:00 · 2ba37bfbe3
commit 2ba37bfbe3
parent ffd4d5e86c
8658 changed files with 2268794 additions and 2538 deletions
--- a/node_modules/gray-matter/CHANGELOG.md
+++ b/node_modules/gray-matter/CHANGELOG.md
@ -0,0 +1,24 @@
+# Release history
+
+## 4.0.0 - 2018-04-01
+
+### Breaking changes
+
+- Now requires node v4 or higher. 
+
+
+## 3.0.0 - 2017-06-30
+
+### Breaking changes
+
+- `toml`, `coffee` and `cson` are no longer supported by default. Please see [`options.engines`](README.md#optionsengines) and the [examples](./examples) to learn how to add engines.
+
+### Added
+
+- Support for [excerpts](README.md#optionsexcerpt).
+- The returned object now has non-enumerable `matter` and `stringify` properties.
+
+### Changed
+
+- Refactored engines (parsers), so that it's easier to add parsers and stringifiers.
+- `options.parsers` was renamed to [`options.engines`](README.md#optionsengines)
--- a/node_modules/gray-matter/LICENSE
+++ b/node_modules/gray-matter/LICENSE
@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018, Jon Schlinkert.
+
+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.
--- a/node_modules/gray-matter/README.md
+++ b/node_modules/gray-matter/README.md
@ -0,0 +1,565 @@
+# gray-matter [![NPM version](https://img.shields.io/npm/v/gray-matter.svg?style=flat)](https://www.npmjs.com/package/gray-matter) [![NPM monthly downloads](https://img.shields.io/npm/dm/gray-matter.svg?style=flat)](https://npmjs.org/package/gray-matter) [![NPM total downloads](https://img.shields.io/npm/dt/gray-matter.svg?style=flat)](https://npmjs.org/package/gray-matter) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/gray-matter.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/gray-matter)
+
+> Parse front-matter from a string or file. Fast, reliable and easy to use. Parses YAML front matter by default, but also has support for YAML, JSON, TOML or Coffee Front-Matter, with options to set custom delimiters. Used by metalsmith, assemble, verb and many other projects.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save gray-matter
+```
+
+## Heads up!
+
+Please see the [changelog](CHANGELOG.md) to learn about breaking changes that were made in v3.0.
+
+## What does this do?
+
+<details>
+<summary><strong>Run this example</strong></summary>
+
+Add the HTML in the following example to `example.html`, then add the following code to `example.js` and run `$ node example` (without the `$`):
+
+```js
+const fs = require('fs');
+const matter = require('gray-matter');
+const str = fs.readFileSync('example.html', 'utf8');
+console.log(matter(str));
+```
+
+</details>
+
+Converts a string with front-matter, like this:
+
+```handlebars
+---
+title: Hello
+slug: home
+---
+<h1>Hello world!</h1>
+```
+
+Into an object like this:
+
+```js
+{
+  content: '<h1>Hello world!</h1>',
+  data: { 
+    title: 'Hello', 
+    slug: 'home' 
+  }
+}
+```
+
+## Why use gray-matter?
+
+* **simple**: main function takes a string and returns an object
+* **accurate**: better at catching and handling edge cases than front-matter parsers that rely on regex for parsing
+* **fast**: faster than other front-matter parsers that use regex for parsing
+* **flexible**: By default, gray-matter is capable of parsing [YAML](https://github.com/nodeca/js-yaml), [JSON](http://en.wikipedia.org/wiki/Json) and JavaScript front-matter. But other [engines](#optionsengines) may be added.
+* **extensible**: Use [custom delimiters](#optionsdelimiters), or add support for [any language](#optionsengines), like [TOML](http://github.com/mojombo/toml), [CoffeeScript](http://coffeescript.org), or [CSON](https://github.com/bevry/cson)
+* **battle-tested**: used by [assemble](https://github.com/assemble/assemble), [metalsmith](https://github.com/segmentio/metalsmith), [phenomic](https://github.com/phenomic/phenomic), [verb](https://github.com/assemble/verb), [generate](https://github.com/generate/generate), [update](https://github.com/update/update) and many others.
+
+<details>
+<summary><strong>Rationale</strong></summary>
+
+**Why did we create gray-matter in the first place?**
+
+We created gray-matter after trying out other libraries that failed to meet our standards and requirements.
+
+Some libraries met most of the requirements, but _none met all of them_.
+
+**Here are the most important**:
+
+* Be usable, if not simple
+* Use a dependable and well-supported library for parsing YAML
+* Support other languages besides YAML
+* Support stringifying back to YAML or another language
+* Don't fail when no content exists
+* Don't fail when no front matter exists
+* Don't use regex for parsing. This is a relatively simple parsing operation, and regex is the slowest and most error-prone way to do it.
+* Have no problem reading YAML files directly
+* Have no problem with complex content, including **non-front-matter** fenced code blocks that contain examples of YAML front matter. Other parsers fail on this.
+* Support stringifying back to front-matter. This is useful for linting, updating properties, etc.
+* Allow custom delimiters, when it's necessary for avoiding delimiter collision.
+* Should return an object with at least these three properties:
+  - `data`: the parsed YAML front matter, as a JSON object
+  - `content`: the contents as a string, without the front matter
+  - `orig`: the "original" content (for debugging)
+
+</details>
+
+## Usage
+
+Using Node's `require()` system:
+
+```js
+const matter = require('gray-matter');
+```
+
+Or with [typescript](https://www.typescriptlang.org)
+
+```js
+import matter = require('gray-matter');
+// OR
+import * as matter from 'gray-matter';
+```
+
+Pass a string and [options](#options) to gray-matter:
+
+```js
+console.log(matter('---\ntitle: Front Matter\n---\nThis is content.'));
+```
+
+Returns:
+
+```js
+{
+  content: '\nThis is content.',
+  data: { 
+    title: 'Front Matter' 
+  } 
+}
+```
+
+More about the returned object in the following section.
+
+***
+
+## Returned object
+
+gray-matter returns a `file` object with the following properties.
+
+**Enumerable**
+
+* `file.data` **{Object}**: the object created by parsing front-matter
+* `file.content` **{String}**: the input string, with `matter` stripped
+* `file.excerpt` **{String}**: an excerpt, if [defined on the options](#optionsexcerpt)
+* `file.empty` **{String}**: when the front-matter is "empty" (either all whitespace, nothing at all, or just comments and no data), the original string is set on this property. See [#65](https://github.com/jonschlinkert/gray-matter/issues/65) for details regarding use case.
+* `file.isEmpty` **{Boolean}**: true if front-matter is empty.
+
+**Non-enumerable**
+
+In addition, the following non-enumberable properties are added to the object to help with debugging.
+
+* `file.orig` **{Buffer}**: the original input string (or buffer)
+* `file.language` **{String}**: the front-matter language that was parsed. `yaml` is the default
+* `file.matter` **{String}**: the _raw_, un-parsed front-matter string
+* `file.stringify` **{Function}**: [stringify](#stringify) the file by converting `file.data` to a string in the given language, wrapping it in delimiters and prepending it to `file.content`.
+
+## Run the examples
+
+If you'd like to test-drive the examples, first clone gray-matter into `my-project` (or wherever you want):
+
+```sh
+$ git clone https://github.com/jonschlinkert/gray-matter my-project
+```
+
+CD into `my-project` and install dependencies:
+
+```sh
+$ cd my-project && npm install
+```
+
+Then run any of the [examples](./examples) to see how gray-matter works:
+
+```sh
+$ node examples/<example_name>
+```
+
+**Links to examples**
+
+* [coffee](examples/coffee.js)
+* [excerpt-separator](examples/excerpt-separator.js)
+* [excerpt-stringify](examples/excerpt-stringify.js)
+* [excerpt](examples/excerpt.js)
+* [javascript](examples/javascript.js)
+* [json-stringify](examples/json-stringify.js)
+* [json](examples/json.js)
+* [restore-empty](examples/restore-empty.js)
+* [sections-excerpt](examples/sections-excerpt.js)
+* [sections](examples/sections.js)
+* [toml](examples/toml.js)
+* [yaml-stringify](examples/yaml-stringify.js)
+* [yaml](examples/yaml.js)
+
+## API
+
+### [matter](index.js#L29)
+
+Takes a string or object with `content` property, extracts and parses front-matter from the string, then returns an object with `data`, `content` and other [useful properties](#returned-object).
+
+**Params**
+
+* `input` **{Object|String}**: String, or object with `content` string
+* `options` **{Object}**
+* `returns` **{Object}**
+
+**Example**
+
+```js
+const matter = require('gray-matter');
+console.log(matter('---\ntitle: Home\n---\nOther stuff'));
+//=> { data: { title: 'Home'}, content: 'Other stuff' }
+```
+
+### [.stringify](index.js#L160)
+
+Stringify an object to YAML or the specified language, and append it to the given string. By default, only YAML and JSON can be stringified. See the [engines](#engines) section to learn how to stringify other languages.
+
+**Params**
+
+* `file` **{String|Object}**: The content string to append to stringified front-matter, or a file object with `file.content` string.
+* `data` **{Object}**: Front matter to stringify.
+* `options` **{Object}**: [Options](#options) to pass to gray-matter and [js-yaml](https://github.com/nodeca/js-yaml).
+* `returns` **{String}**: Returns a string created by wrapping stringified yaml with delimiters, and appending that to the given string.
+
+**Example**
+
+```js
+console.log(matter.stringify('foo bar baz', {title: 'Home'}));
+// results in:
+// ---
+// title: Home
+// ---
+// foo bar baz
+```
+
+### [.read](index.js#L178)
+
+Synchronously read a file from the file system and parse front matter. Returns the same object as the [main function](#matter).
+
+**Params**
+
+* `filepath` **{String}**: file path of the file to read.
+* `options` **{Object}**: [Options](#options) to pass to gray-matter.
+* `returns` **{Object}**: Returns [an object](#returned-object) with `data` and `content`
+
+**Example**
+
+```js
+const file = matter.read('./content/blog-post.md');
+```
+
+### [.test](index.js#L193)
+
+Returns true if the given `string` has front matter.
+
+**Params**
+
+* `string` **{String}**
+* `options` **{Object}**
+* `returns` **{Boolean}**: True if front matter exists.
+
+## Options
+
+### options.excerpt
+
+**Type**: `Boolean|Function`
+
+**Default**: `undefined`
+
+Extract an excerpt that directly follows front-matter, or is the first thing in the string if no front-matter exists.
+
+If set to `excerpt: true`, it will look for the frontmatter delimiter, `---` by default and grab everything leading up to it.
+
+**Example**
+
+```js
+const str = '---\nfoo: bar\n---\nThis is an excerpt.\n---\nThis is content';
+const file = matter(str, { excerpt: true });
+```
+
+Results in:
+
+```js
+{ 
+  content: 'This is an excerpt.\n---\nThis is content',
+  data: { foo: 'bar' },
+  excerpt: 'This is an excerpt.\n' 
+}
+```
+
+You can also set `excerpt` to a function. This function uses the 'file' and 'options' that were initially passed to gray-matter as parameters, so you can control how the excerpt is extracted from the content.
+
+**Example**
+
+```js
+// returns the first 4 lines of the contents
+function firstFourLines(file, options) {
+  file.excerpt = file.content.split('\n').slice(0, 4).join(' ');
+}
+
+const file =  matter([
+  '---',
+  'foo: bar',
+  '---',
+  'Only this',
+  'will be',
+  'in the',
+  'excerpt',
+  'but not this...'
+].join('\n'), {excerpt: firstFourLines});
+```
+
+Results in:
+
+```js
+{ 
+  content: 'Only this\nwill be\nin the\nexcerpt\nbut not this...',
+  data: { foo: 'bar' },
+  excerpt: 'Only this will be in the excerpt'
+}
+```
+
+### options.excerpt_separator
+
+**Type**: `String`
+
+**Default**: `undefined`
+
+Define a custom separator to use for excerpts.
+
+```js
+console.log(matter(string, {excerpt_separator: '<!-- end -->'}));
+```
+
+**Example**
+
+The following HTML string:
+
+```html
+---
+title: Blog
+---
+My awesome blog.
+<!-- end -->
+<h1>Hello world</h1>
+```
+
+Results in:
+
+```js
+{ 
+  data: { title: 'Blog'}, 
+  excerpt: 'My awesome blog.', 
+  content: 'My awesome blog.\n<!-- end -->\n<h1>Hello world</h1>' 
+}
+```
+
+### options.engines
+
+Define custom engines for parsing and/or stringifying front-matter.
+
+**Type**: `Object` Object of engines
+
+**Default**: `JSON`, `YAML` and `JavaScript` are already handled by default.
+
+**Engine format**
+
+Engines may either be an object with `parse` and (optionally) `stringify` methods, or a function that will be used for parsing only.
+
+**Examples**
+
+```js
+const toml = require('toml');
+
+/**
+ * defined as a function
+ */
+
+const file = matter(str, {
+  engines: {
+    toml: toml.parse.bind(toml),
+  }
+});
+
+/**
+ * Or as an object
+ */
+
+const file = matter(str, {
+  engines: {
+    toml: {
+      parse: toml.parse.bind(toml),
+
+      // example of throwing an error to let users know stringifying is
+      // not supported (a TOML stringifier might exist, this is just an example)
+      stringify: function() {
+        throw new Error('cannot stringify to TOML');
+      }
+    }
+  }
+});
+
+console.log(file);
+```
+
+### options.language
+
+**Type**: `String`
+
+**Default**: `yaml`
+
+Define the engine to use for parsing front-matter.
+
+```js
+console.log(matter(string, {language: 'toml'}));
+```
+
+**Example**
+
+The following HTML string:
+
+```html
+---
+title = "TOML"
+description = "Front matter"
+categories = "front matter toml"
+---
+This is content
+```
+
+Results in:
+
+```js
+{ content: 'This is content',
+  excerpt: '',
+  data:
+   { title: 'TOML',
+     description: 'Front matter',
+     categories: 'front matter toml' } }
+```
+
+**Dynamic language detection**
+
+Instead of defining the language on the options, gray-matter will automatically detect the language defined after the first delimiter and select the correct engine to use for parsing.
+
+```html
+---toml
+title = "TOML"
+description = "Front matter"
+categories = "front matter toml"
+---
+This is content
+```
+
+### options.delimiters
+
+**Type**: `String`
+
+**Default**: `---`
+
+Open and close delimiters can be passed in as an array of strings.
+
+**Example:**
+
+```js
+// format delims as a string
+matter.read('file.md', {delims: '~~~'});
+// or an array (open/close)
+matter.read('file.md', {delims: ['~~~', '~~~']});
+```
+
+would parse:
+
+```html
+~~~
+title: Home
+~~~
+This is the {{title}} page.
+```
+
+## Deprecated options
+
+### options.lang
+
+Decrecated, please use [options.language](#optionslanguage) instead.
+
+### options.delims
+
+Decrecated, please use [options.delimiters](#optionsdelimiters) instead.
+
+### options.parsers
+
+Decrecated, please use [options.engines](#optionsengines) instead.
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [assemble](https://www.npmjs.com/package/assemble): Get the rocks out of your socks! Assemble makes you fast at creating web projects… [more](https://github.com/assemble/assemble) | [homepage](https://github.com/assemble/assemble "Get the rocks out of your socks! Assemble makes you fast at creating web projects. Assemble is used by thousands of projects for rapid prototyping, creating themes, scaffolds, boilerplates, e-books, UI components, API documentation, blogs, building websit")
+* [metalsmith](https://www.npmjs.com/package/metalsmith): An extremely simple, pluggable static site generator. | [homepage](https://github.com/segmentio/metalsmith#readme "An extremely simple, pluggable static site generator.")
+* [verb](https://www.npmjs.com/package/verb): Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used… [more](https://github.com/verbose/verb) | [homepage](https://github.com/verbose/verb "Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used on hundreds of projects of all sizes to generate everything from API docs to readmes.")
+* [gray-matter-loader](https://github.com/atlassian/gray-matter-loader): A webpack loader for gray-matter. [homepage](https://github.com/atlassian/gray-matter-loader#gray-matter-loader)
+
+### Contributors
+
+| **Commits** | **Contributor** | 
+| --- | --- |
+| 174 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 7 | [RobLoach](https://github.com/RobLoach) |
+| 5 | [heymind](https://github.com/heymind) |
+| 4 | [doowb](https://github.com/doowb) |
+| 3 | [aljopro](https://github.com/aljopro) |
+| 2 | [reccanti](https://github.com/reccanti) |
+| 2 | [onokumus](https://github.com/onokumus) |
+| 2 | [moozzyk](https://github.com/moozzyk) |
+| 1 | [Ajedi32](https://github.com/Ajedi32) |
+| 1 | [caesar](https://github.com/caesar) |
+| 1 | [ianstormtaylor](https://github.com/ianstormtaylor) |
+| 1 | [qm3ster](https://github.com/qm3ster) |
+| 1 | [zachwhaley](https://github.com/zachwhaley) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on April 01, 2018._
--- a/node_modules/gray-matter/gray-matter.d.ts
+++ b/node_modules/gray-matter/gray-matter.d.ts
@ -0,0 +1,114 @@
+/**
+ * Takes a string or object with `content` property, extracts
+ * and parses front-matter from the string, then returns an object
+ * with `data`, `content` and other [useful properties](#returned-object).
+ *
+ * ```js
+ * var matter = require('gray-matter');
+ * console.log(matter('---\ntitle: Home\n---\nOther stuff'));
+ * //=> { data: { title: 'Home'}, content: 'Other stuff' }
+ * ```
+ * @param {Object|String} `input` String, or object with `content` string
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+declare function matter<
+  I extends matter.Input,
+  O extends matter.GrayMatterOption<I, O>
+>(input: I | { content: I }, options?: O): matter.GrayMatterFile<I>
+
+declare namespace matter {
+  type Input = string | Buffer
+  interface GrayMatterOption<
+    I extends Input,
+    O extends GrayMatterOption<I, O>
+  > {
+    parser?: () => void
+    eval?: boolean
+    excerpt?: boolean | ((input: I, options: O) => string)
+    excerpt_separator?: string
+    engines?: {
+      [index: string]:
+        | ((input: string) => object)
+        | { parse: (input: string) => object; stringify?: (data: object) => string }
+    }
+    language?: string
+    delimiters?: string | [string, string]
+  }
+  interface GrayMatterFile<I extends Input> {
+    data: { [key: string]: any }
+    content: string
+    excerpt?: string
+    orig: Buffer | I
+    language: string
+    matter: string
+    stringify(lang: string): string
+  }
+  
+  /**
+   * Stringify an object to YAML or the specified language, and
+   * append it to the given string. By default, only YAML and JSON
+   * can be stringified. See the [engines](#engines) section to learn
+   * how to stringify other languages.
+   *
+   * ```js
+   * console.log(matter.stringify('foo bar baz', {title: 'Home'}));
+   * // results in:
+   * // ---
+   * // title: Home
+   * // ---
+   * // foo bar baz
+   * ```
+   * @param {String|Object} `file` The content string to append to stringified front-matter, or a file object with `file.content` string.
+   * @param {Object} `data` Front matter to stringify.
+   * @param {Object} `options` [Options](#options) to pass to gray-matter and [js-yaml].
+   * @return {String} Returns a string created by wrapping stringified yaml with delimiters, and appending that to the given string.
+   */
+  export function stringify<O extends GrayMatterOption<string, O>>(
+    file: string | { content: string },
+    data: object,
+    options?: GrayMatterOption<string, O>
+  ): string
+
+  /**
+   * Synchronously read a file from the file system and parse
+   * front matter. Returns the same object as the [main function](#matter).
+   *
+   * ```js
+   * var file = matter.read('./content/blog-post.md');
+   * ```
+   * @param {String} `filepath` file path of the file to read.
+   * @param {Object} `options` [Options](#options) to pass to gray-matter.
+   * @return {Object} Returns [an object](#returned-object) with `data` and `content`
+   */
+  export function read<O extends GrayMatterOption<string, O>>(
+    fp: string,
+    options?: GrayMatterOption<string, O>
+  ): matter.GrayMatterFile<string>
+
+  /**
+   * Returns true if the given `string` has front matter.
+   * @param  {String} `string`
+   * @param  {Object} `options`
+   * @return {Boolean} True if front matter exists.
+   */
+  export function test<O extends matter.GrayMatterOption<string, O>>(
+    str: string,
+    options?: GrayMatterOption<string, O>
+  ): boolean
+
+  /**
+   * Detect the language to use, if one is defined after the
+   * first front-matter delimiter.
+   * @param  {String} `string`
+   * @param  {Object} `options`
+   * @return {Object} Object with `raw` (actual language string), and `name`, the language with whitespace trimmed
+   */
+  export function language<O extends matter.GrayMatterOption<string, O>>(
+    str: string,
+    options?: GrayMatterOption<string, O>
+  ): { name: string; raw: string }
+}
+
+export = matter
--- a/node_modules/gray-matter/index.js
+++ b/node_modules/gray-matter/index.js
@ -0,0 +1,228 @@
+'use strict';
+
+const fs = require('fs');
+const sections = require('section-matter');
+const defaults = require('./lib/defaults');
+const stringify = require('./lib/stringify');
+const excerpt = require('./lib/excerpt');
+const engines = require('./lib/engines');
+const toFile = require('./lib/to-file');
+const parse = require('./lib/parse');
+const utils = require('./lib/utils');
+
+/**
+ * Takes a string or object with `content` property, extracts
+ * and parses front-matter from the string, then returns an object
+ * with `data`, `content` and other [useful properties](#returned-object).
+ *
+ * ```js
+ * const matter = require('gray-matter');
+ * console.log(matter('---\ntitle: Home\n---\nOther stuff'));
+ * //=> { data: { title: 'Home'}, content: 'Other stuff' }
+ * ```
+ * @param {Object|String} `input` String, or object with `content` string
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+
+function matter(input, options) {
+  if (input === '') {
+    return { data: {}, content: input, excerpt: '', orig: input };
+  }
+
+  let file = toFile(input);
+  const cached = matter.cache[file.content];
+
+  if (!options) {
+    if (cached) {
+      file = Object.assign({}, cached);
+      file.orig = cached.orig;
+      return file;
+    }
+
+    // only cache if there are no options passed. if we cache when options
+    // are passed, we would need to also cache options values, which would
+    // negate any performance benefits of caching
+    matter.cache[file.content] = file;
+  }
+
+  return parseMatter(file, options);
+}
+
+/**
+ * Parse front matter
+ */
+
+function parseMatter(file, options) {
+  const opts = defaults(options);
+  const open = opts.delimiters[0];
+  const close = '\n' + opts.delimiters[1];
+  let str = file.content;
+
+  if (opts.language) {
+    file.language = opts.language;
+  }
+
+  // get the length of the opening delimiter
+  const openLen = open.length;
+  if (!utils.startsWith(str, open, openLen)) {
+    excerpt(file, opts);
+    return file;
+  }
+
+  // if the next character after the opening delimiter is
+  // a character from the delimiter, then it's not a front-
+  // matter delimiter
+  if (str.charAt(openLen) === open.slice(-1)) {
+    return file;
+  }
+
+  // strip the opening delimiter
+  str = str.slice(openLen);
+  const len = str.length;
+
+  // use the language defined after first delimiter, if it exists
+  const language = matter.language(str, opts);
+  if (language.name) {
+    file.language = language.name;
+    str = str.slice(language.raw.length);
+  }
+
+  // get the index of the closing delimiter
+  let closeIndex = str.indexOf(close);
+  if (closeIndex === -1) {
+    closeIndex = len;
+  }
+
+  // get the raw front-matter block
+  file.matter = str.slice(0, closeIndex);
+
+  const block = file.matter.replace(/^\s*#[^\n]+/gm, '').trim();
+  if (block === '') {
+    file.isEmpty = true;
+    file.empty = file.content;
+    file.data = {};
+  } else {
+
+    // create file.data by parsing the raw file.matter block
+    file.data = parse(file.language, file.matter, opts);
+  }
+
+  // update file.content
+  if (closeIndex === len) {
+    file.content = '';
+  } else {
+    file.content = str.slice(closeIndex + close.length);
+    if (file.content[0] === '\r') {
+      file.content = file.content.slice(1);
+    }
+    if (file.content[0] === '\n') {
+      file.content = file.content.slice(1);
+    }
+  }
+
+  excerpt(file, opts);
+
+  if (opts.sections === true || typeof opts.section === 'function') {
+    sections(file, opts.section);
+  }
+  return file;
+}
+
+/**
+ * Expose engines
+ */
+
+matter.engines = engines;
+
+/**
+ * Stringify an object to YAML or the specified language, and
+ * append it to the given string. By default, only YAML and JSON
+ * can be stringified. See the [engines](#engines) section to learn
+ * how to stringify other languages.
+ *
+ * ```js
+ * console.log(matter.stringify('foo bar baz', {title: 'Home'}));
+ * // results in:
+ * // ---
+ * // title: Home
+ * // ---
+ * // foo bar baz
+ * ```
+ * @param {String|Object} `file` The content string to append to stringified front-matter, or a file object with `file.content` string.
+ * @param {Object} `data` Front matter to stringify.
+ * @param {Object} `options` [Options](#options) to pass to gray-matter and [js-yaml].
+ * @return {String} Returns a string created by wrapping stringified yaml with delimiters, and appending that to the given string.
+ * @api public
+ */
+
+matter.stringify = function(file, data, options) {
+  if (typeof file === 'string') file = matter(file, options);
+  return stringify(file, data, options);
+};
+
+/**
+ * Synchronously read a file from the file system and parse
+ * front matter. Returns the same object as the [main function](#matter).
+ *
+ * ```js
+ * const file = matter.read('./content/blog-post.md');
+ * ```
+ * @param {String} `filepath` file path of the file to read.
+ * @param {Object} `options` [Options](#options) to pass to gray-matter.
+ * @return {Object} Returns [an object](#returned-object) with `data` and `content`
+ * @api public
+ */
+
+matter.read = function(filepath, options) {
+  const str = fs.readFileSync(filepath, 'utf8');
+  const file = matter(str, options);
+  file.path = filepath;
+  return file;
+};
+
+/**
+ * Returns true if the given `string` has front matter.
+ * @param  {String} `string`
+ * @param  {Object} `options`
+ * @return {Boolean} True if front matter exists.
+ * @api public
+ */
+
+matter.test = function(str, options) {
+  return utils.startsWith(str, defaults(options).delimiters[0]);
+};
+
+/**
+ * Detect the language to use, if one is defined after the
+ * first front-matter delimiter.
+ * @param  {String} `string`
+ * @param  {Object} `options`
+ * @return {Object} Object with `raw` (actual language string), and `name`, the language with whitespace trimmed
+ */
+
+matter.language = function(str, options) {
+  const opts = defaults(options);
+  const open = opts.delimiters[0];
+
+  if (matter.test(str)) {
+    str = str.slice(open.length);
+  }
+
+  const language = str.slice(0, str.search(/\r?\n/));
+  return {
+    raw: language,
+    name: language ? language.trim() : ''
+  };
+};
+
+/**
+ * Expose `matter`
+ */
+
+matter.cache = {};
+matter.clearCache = function() {
+  matter.cache = {};
+};
+module.exports = matter;
--- a/node_modules/gray-matter/lib/defaults.js
+++ b/node_modules/gray-matter/lib/defaults.js
@ -0,0 +1,18 @@
+'use strict';
+
+const engines = require('./engines');
+const utils = require('./utils');
+
+module.exports = function(options) {
+  const opts = Object.assign({}, options);
+
+  // ensure that delimiters are an array
+  opts.delimiters = utils.arrayify(opts.delims || opts.delimiters || '---');
+  if (opts.delimiters.length === 1) {
+    opts.delimiters.push(opts.delimiters[0]);
+  }
+
+  opts.language = (opts.language || opts.lang || 'yaml').toLowerCase();
+  opts.engines = Object.assign({}, engines, opts.parsers, opts.engines);
+  return opts;
+};
--- a/node_modules/gray-matter/lib/engine.js
+++ b/node_modules/gray-matter/lib/engine.js
@ -0,0 +1,30 @@
+'use strict';
+
+module.exports = function(name, options) {
+  let engine = options.engines[name] || options.engines[aliase(name)];
+  if (typeof engine === 'undefined') {
+    throw new Error('gray-matter engine "' + name + '" is not registered');
+  }
+  if (typeof engine === 'function') {
+    engine = { parse: engine };
+  }
+  return engine;
+};
+
+function aliase(name) {
+  switch (name.toLowerCase()) {
+    case 'js':
+    case 'javascript':
+      return 'javascript';
+    case 'coffee':
+    case 'coffeescript':
+    case 'cson':
+      return 'coffee';
+    case 'yaml':
+    case 'yml':
+      return 'yaml';
+    default: {
+      return name;
+    }
+  }
+}
--- a/node_modules/gray-matter/lib/engines.js
+++ b/node_modules/gray-matter/lib/engines.js
@ -0,0 +1,54 @@
+'use strict';
+
+const yaml = require('js-yaml');
+
+/**
+ * Default engines
+ */
+
+const engines = exports = module.exports;
+
+/**
+ * YAML
+ */
+
+engines.yaml = {
+  parse: yaml.safeLoad.bind(yaml),
+  stringify: yaml.safeDump.bind(yaml)
+};
+
+/**
+ * JSON
+ */
+
+engines.json = {
+  parse: JSON.parse.bind(JSON),
+  stringify: function(obj, options) {
+    const opts = Object.assign({replacer: null, space: 2}, options);
+    return JSON.stringify(obj, opts.replacer, opts.space);
+  }
+};
+
+/**
+ * JavaScript
+ */
+
+engines.javascript = {
+  parse: function parse(str, options, wrap) {
+    /* eslint no-eval: 0 */
+    try {
+      if (wrap !== false) {
+        str = '(function() {\nreturn ' + str.trim() + ';\n}());';
+      }
+      return eval(str) || {};
+    } catch (err) {
+      if (wrap !== false && /(unexpected|identifier)/i.test(err.message)) {
+        return parse(str, options, false);
+      }
+      throw new SyntaxError(err);
+    }
+  },
+  stringify: function() {
+    throw new Error('stringifying JavaScript is not supported');
+  }
+};
--- a/node_modules/gray-matter/lib/excerpt.js
+++ b/node_modules/gray-matter/lib/excerpt.js
@ -0,0 +1,32 @@
+'use strict';
+
+const defaults = require('./defaults');
+
+module.exports = function(file, options) {
+  const opts = defaults(options);
+
+  if (file.data == null) {
+    file.data = {};
+  }
+
+  if (typeof opts.excerpt === 'function') {
+    return opts.excerpt(file, opts);
+  }
+
+  const sep = file.data.excerpt_separator || opts.excerpt_separator;
+  if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
+    return file;
+  }
+
+  const delimiter = typeof opts.excerpt === 'string'
+    ? opts.excerpt
+    : (sep || opts.delimiters[0]);
+
+  // if enabled, get the excerpt defined after front-matter
+  const idx = file.content.indexOf(delimiter);
+  if (idx !== -1) {
+    file.excerpt = file.content.slice(0, idx);
+  }
+
+  return file;
+};
--- a/node_modules/gray-matter/lib/parse.js
+++ b/node_modules/gray-matter/lib/parse.js
@ -0,0 +1,13 @@
+'use strict';
+
+const getEngine = require('./engine');
+const defaults = require('./defaults');
+
+module.exports = function(language, str, options) {
+  const opts = defaults(options);
+  const engine = getEngine(language, opts);
+  if (typeof engine.parse !== 'function') {
+    throw new TypeError('expected "' + language + '.parse" to be a function');
+  }
+  return engine.parse(str, opts);
+};
--- a/node_modules/gray-matter/lib/stringify.js
+++ b/node_modules/gray-matter/lib/stringify.js
@ -0,0 +1,56 @@
+'use strict';
+
+const typeOf = require('kind-of');
+const getEngine = require('./engine');
+const defaults = require('./defaults');
+
+module.exports = function(file, data, options) {
+  if (data == null && options == null) {
+    switch (typeOf(file)) {
+      case 'object':
+        data = file.data;
+        options = {};
+        break;
+      case 'string':
+        return file;
+      default: {
+        throw new TypeError('expected file to be a string or object');
+      }
+    }
+  }
+
+  const str = file.content;
+  const opts = defaults(options);
+  if (data == null) {
+    if (!opts.data) return file;
+    data = opts.data;
+  }
+
+  const language = file.language || opts.language;
+  const engine = getEngine(language, opts);
+  if (typeof engine.stringify !== 'function') {
+    throw new TypeError('expected "' + language + '.stringify" to be a function');
+  }
+
+  data = Object.assign({}, file.data, data);
+  const open = opts.delimiters[0];
+  const close = opts.delimiters[1];
+  const matter = engine.stringify(data, options).trim();
+  let buf = '';
+
+  if (matter !== '{}') {
+    buf = newline(open) + newline(matter) + newline(close);
+  }
+
+  if (typeof file.excerpt === 'string' && file.excerpt !== '') {
+    if (str.indexOf(file.excerpt.trim()) === -1) {
+      buf += newline(file.excerpt) + newline(close);
+    }
+  }
+
+  return buf + newline(str);
+};
+
+function newline(str) {
+  return str.slice(-1) !== '\n' ? str + '\n' : str;
+}
--- a/node_modules/gray-matter/lib/to-file.js
+++ b/node_modules/gray-matter/lib/to-file.js
@ -0,0 +1,43 @@
+'use strict';
+
+const typeOf = require('kind-of');
+const stringify = require('./stringify');
+const utils = require('./utils');
+
+/**
+ * Normalize the given value to ensure an object is returned
+ * with the expected properties.
+ */
+
+module.exports = function(file) {
+  if (typeOf(file) !== 'object') {
+    file = { content: file };
+  }
+
+  if (typeOf(file.data) !== 'object') {
+    file.data = {};
+  }
+
+  // if file was passed as an object, ensure that
+  // "file.content" is set
+  if (file.contents && file.content == null) {
+    file.content = file.contents;
+  }
+
+  // set non-enumerable properties on the file object
+  utils.define(file, 'orig', utils.toBuffer(file.content));
+  utils.define(file, 'language', file.language || '');
+  utils.define(file, 'matter', file.matter || '');
+  utils.define(file, 'stringify', function(data, options) {
+    if (options && options.language) {
+      file.language = options.language;
+    }
+    return stringify(file, data, options);
+  });
+
+  // strip BOM and ensure that "file.content" is a string
+  file.content = utils.toString(file.content);
+  file.isEmpty = false;
+  file.excerpt = '';
+  return file;
+};
--- a/node_modules/gray-matter/lib/utils.js
+++ b/node_modules/gray-matter/lib/utils.js
@ -0,0 +1,66 @@
+'use strict';
+
+const stripBom = require('strip-bom-string');
+const typeOf = require('kind-of');
+
+exports.define = function(obj, key, val) {
+  Reflect.defineProperty(obj, key, {
+    enumerable: false,
+    configurable: true,
+    writable: true,
+    value: val
+  });
+};
+
+/**
+ * Returns true if `val` is a buffer
+ */
+
+exports.isBuffer = function(val) {
+  return typeOf(val) === 'buffer';
+};
+
+/**
+ * Returns true if `val` is an object
+ */
+
+exports.isObject = function(val) {
+  return typeOf(val) === 'object';
+};
+
+/**
+ * Cast `input` to a buffer
+ */
+
+exports.toBuffer = function(input) {
+  return typeof input === 'string' ? Buffer.from(input) : input;
+};
+
+/**
+ * Cast `val` to a string.
+ */
+
+exports.toString = function(input) {
+  if (exports.isBuffer(input)) return stripBom(String(input));
+  if (typeof input !== 'string') {
+    throw new TypeError('expected input to be a string or buffer');
+  }
+  return stripBom(input);
+};
+
+/**
+ * Cast `val` to an array.
+ */
+
+exports.arrayify = function(val) {
+  return val ? (Array.isArray(val) ? val : [val]) : [];
+};
+
+/**
+ * Returns true if `str` starts with `substr`.
+ */
+
+exports.startsWith = function(str, substr, len) {
+  if (typeof len !== 'number') len = substr.length;
+  return str.slice(0, len) === substr;
+};
--- a/node_modules/gray-matter/node_modules/.bin/js-yaml
+++ b/node_modules/gray-matter/node_modules/.bin/js-yaml
@ -0,0 +1 @@
+../../../js-yaml/bin/js-yaml.js
--- a/node_modules/gray-matter/package.json
+++ b/node_modules/gray-matter/package.json
@ -0,0 +1,127 @@
+{
+  "name": "gray-matter",
+  "description": "Parse front-matter from a string or file. Fast, reliable and easy to use. Parses YAML front matter by default, but also has support for YAML, JSON, TOML or Coffee Front-Matter, with options to set custom delimiters. Used by metalsmith, assemble, verb and many other projects.",
+  "version": "4.0.3",
+  "homepage": "https://github.com/jonschlinkert/gray-matter",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "Andrew Meyer (https://github.com/Ajedi32)",
+    "Brian Woodward (https://twitter.com/doowb)",
+    "Caesar Schinas (https://caesarschinas.com)",
+    "Ian Storm Taylor (http://ianstormtaylor.com)",
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Osman Nuri Okumuş (http://onokumus.com)",
+    "Pawel Kadluczka (http://blog.3d-logic.com)",
+    "Rob Loach (http://robloach.net)",
+    "(https://github.com/heymind)",
+    "Zach Whaley (http://zachwhaleys.website)"
+  ],
+  "repository": "jonschlinkert/gray-matter",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/gray-matter/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "gray-matter.d.ts",
+    "index.js",
+    "lib"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=6.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "js-yaml": "^3.13.1",
+    "kind-of": "^6.0.2",
+    "section-matter": "^1.0.0",
+    "strip-bom-string": "^1.0.0"
+  },
+  "devDependencies": {
+    "ansi-green": "^0.1.1",
+    "benchmarked": "^2.0.0",
+    "coffeescript": "^2.2.3",
+    "delimiter-regex": "^2.0.0",
+    "extend-shallow": "^3.0.2",
+    "front-matter": "^2.3.0",
+    "gulp-format-md": "^1.0.0",
+    "minimist": "^1.2.0",
+    "mocha": "^6.1.4",
+    "toml": "^2.3.3",
+    "vinyl": "^2.1.0",
+    "write": "^1.0.3"
+  },
+  "keywords": [
+    "assemble",
+    "coffee",
+    "coffee-script",
+    "data",
+    "docs",
+    "documentation",
+    "extract",
+    "extracting",
+    "front",
+    "front-matter",
+    "frontmatter",
+    "generate",
+    "generator",
+    "gh-pages",
+    "gray",
+    "javascript",
+    "jekyll",
+    "js",
+    "JSON",
+    "markdown",
+    "matter",
+    "parse",
+    "parser",
+    "parsing",
+    "site",
+    "static",
+    "template",
+    "toml",
+    "yaml",
+    "yfm"
+  ],
+  "browser": {
+    "fs": false
+  },
+  "typings": "gray-matter.d.ts",
+  "eslintConfig": {
+    "rules": {
+      "no-console": 0
+    }
+  },
+  "verb": {
+    "toc": false,
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "helpers": {
+      "examples": "./examples/helper.js"
+    },
+    "lint": {
+      "reflinks": true
+    },
+    "related": {
+      "list": [
+        "assemble",
+        "metalsmith",
+        "verb"
+      ]
+    },
+    "reflinks": [
+      "coffe-script",
+      "generate",
+      "js-yaml",
+      "toml",
+      "update"
+    ]
+  }
+}