hexo-component-inferno 4.0.0 → 4.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 PPOffice
+
+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/README.md

@@ -1,19 +1,170 @@
-# A collection of [Inferno.js](https://infernojs.org/) layout components and utility scripts for Hexo
+# hexo-component-inferno
 
-[![Build Status](https://github.com/ppoffice/hexo-component-inferno/workflows/Test/badge.svg?branch=master)](https://github.com/ppoffice/hexo-component-inferno/actions)
-[![NPM version](https://badge.fury.io/js/hexo-component-inferno.svg)](https://www.npmjs.com/package/hexo-component-inferno)
+[![Test](https://github.com/ppoffice/hexo-component-inferno/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/ppoffice/hexo-component-inferno/actions/workflows/test.yml)
+[![npm version](https://img.shields.io/npm/v/hexo-component-inferno.svg)](https://www.npmjs.com/package/hexo-component-inferno)
 [![Coverage Status](https://img.shields.io/coveralls/ppoffice/hexo-component-inferno.svg)](https://coveralls.io/r/ppoffice/hexo-component-inferno?branch=master)
 
+Ready-made [Inferno.js](https://infernojs.org/) layout components, Hexo extensions, and configuration tools
+for building [Hexo](https://hexo.io/) themes in JSX. It is the component library behind
+[Icarus](https://github.com/ppoffice/hexo-theme-icarus), and any theme rendered with
+[hexo-renderer-inferno](https://github.com/hexojs/hexo-renderer-inferno) can use it.
+
+- **Components**: comment systems, search, share buttons, donation buttons, widgets, analytics and other
+  plugins, and SEO metadata, each with a JSON schema for its configuration.
+- **Hexo extensions**: generators, helpers, tag plugins, and a filter that merges the theme config into
+  the template locals.
+- **Configuration tools**: a JSON schema loader that validates the theme config and generates its default
+  values, and a framework for migrating configs between theme versions.
+
+## Requirements
+
+- Node.js 14 or later
+- Hexo 7.1.1 or later, or Hexo 8 (a peer dependency)
+
 ## Install
 
 ```sh
-$ npm install hexo-component-inferno --save
+npm install hexo-component-inferno
 ```
 
-## API Documentation
+The components render [Bulma](https://bulma.io/) markup and [Font Awesome](https://fontawesome.com/)
+icons, so your theme needs to include their styles.
+
+## Usage
+
+The examples below follow how Icarus uses this library. See its
+[`include/register.js`](https://github.com/ppoffice/hexo-theme-icarus/blob/master/include/register.js) and
+[`layout/common/`](https://github.com/ppoffice/hexo-theme-icarus/tree/master/layout/common) for a complete
+example.
+
+### Register the Hexo extensions
+
+Register the extensions you need from a script of your theme, for example `scripts/index.js`:
+
+```js
+require('hexo-component-inferno/lib/hexo/filter/locals')(hexo);
+require('hexo-component-inferno/lib/hexo/generator/assets')(hexo);
+require('hexo-component-inferno/lib/hexo/helper/cdn')(hexo);
+require('hexo-component-inferno/lib/hexo/tag/message')(hexo);
+// ...
+require('hexo-component-inferno/lib/core/view').init(hexo);
+```
+
+| Module                      | What it registers                                                                                                                                                                                                                                   |
+| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `hexo/filter/locals`        | Merges the theme config, `_config.post.yml` / `_config.page.yml`, and the front matter of the page into `config`, and puts all helpers in `helper`. Most components expect these locals.                                                            |
+| `hexo/generator/assets`     | Copies the browser scripts in [`asset/`](asset) (search, table of contents) to the site, unless the theme has a file at the same path.                                                                                                              |
+| `hexo/generator/insight`    | `content.json`, the index of the Insight search.                                                                                                                                                                                                    |
+| `hexo/generator/manifest`   | `manifest.json` for web apps.                                                                                                                                                                                                                       |
+| `hexo/generator/categories` | The `/categories/` page.                                                                                                                                                                                                                            |
+| `hexo/generator/category`   | The page of each category.                                                                                                                                                                                                                          |
+| `hexo/generator/tags`       | The `/tags/` page.                                                                                                                                                                                                                                  |
+| `hexo/helper/cdn`           | `cdn(package, version, file)`, `fontcdn(name, type)` and `iconcdn()`, which build URLs for the CDN providers set in `providers.cdn`, `providers.fontcdn` and `providers.iconcdn`. `providers.cdn_overrides` sets a different CDN for some packages. |
+| `hexo/helper/page`          | `is_categories()` and `is_tags()`.                                                                                                                                                                                                                  |
+| `hexo/tag/message`          | The `{% message %}` tag for Bulma message boxes.                                                                                                                                                                                                    |
+| `hexo/tag/tabs`             | The `{% tabs %}` tag for Bulma tabs.                                                                                                                                                                                                                |
+
+### Render components
+
+Every component lives in `lib/view/<category>/<name>.js`. Each one has a `Cacheable` version that takes
+the template locals (`config`, `page`, `helper` and `site`) together with its own section of the theme
+config, maps them to its props, and caches the rendered element:
+
+```jsx
+const { Component } = require('inferno');
+const view = require('hexo-component-inferno/lib/core/view');
+
+module.exports = class extends Component {
+  render() {
+    const { config, page, helper } = this.props;
+    const { comment } = config;
+    // Resolves layout/comment/<type>.jsx in the theme first, then lib/view/comment/<type>.js here
+    const Comment = view.require('comment/' + comment.type);
+    return <Comment.Cacheable config={config} page={page} helper={helper} comment={comment} />;
+  }
+};
+```
+
+Because `view.require()` looks in the theme's `layout/` directory first, a theme can replace any component
+by adding a file with the same path.
+
+### Validate the theme config
+
+The JSON schema of each component is in `lib/schema/<category>/<name>.json`. Load your theme's schema
+with `SchemaLoader`. A `$ref` is resolved from the directories you pass in first, then from the schemas of
+this library:
+
+```js
+const { SchemaLoader } = require('hexo-component-inferno/lib/core/schema');
+
+const loader = SchemaLoader.load(require('./schema/config.json'), [path.join(__dirname, 'schema')]);
+const schema = loader.getSchema('/config.json');
+
+const result = schema.validate(themeConfig); // true, or a list of errors
+const defaults = schema.getDefaultValue().toYaml(); // a commented default config
+```
+
+For example, `{ "$ref": "/comment/giscus.json" }` in your schema refers to the Giscus schema of this
+library. `lib/core/migrate` upgrades existing configs between theme versions with a chain of `Migration`
+classes.
+
+### Utilities
+
+| Module            | Description                                                                                                       |
+| ----------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `util/cache`      | `cacheComponent()`, which builds the `Cacheable` components.                                                      |
+| `util/classname`  | Builds a class name string from a string, an array, or an object of class names to booleans.                      |
+| `util/yaml`       | YAML parse and stringify for theme configs, writing `null` as an empty value.                                     |
+| `util/script`     | Builds inline scripts that load external scripts without blocking the page and work with PJAX.                    |
+| `util/appearance` | Builds inline expressions that follow the light, dark, or auto appearance of the page (`<html data-appearance>`). |
+| `util/i18n`       | Translates a key with a fallback when the theme has no translation.                                               |
+| `util/deprecate`  | Warns once when a deprecated component is rendered.                                                               |
+
+## Components
+
+| Category  | Components                                                                                                                                                                                                                             |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `comment` | Artalk, Beaudar, Changyan, Cusdis, Disqus, DisqusJS, Facebook, Giscus, Gitalk, Gitment, Isso, LiveRe, Twikoo, Utterances, Valine, Waline                                                                                               |
+| `search`  | Algolia, Baidu, Google CSE, Insight                                                                                                                                                                                                    |
+| `share`   | AddThis, AddToAny, Baidu Share, Share.js, ShareThis                                                                                                                                                                                    |
+| `donate`  | Afdian, Alipay, Buy Me a Coffee, Patreon, PayPal, WeChat                                                                                                                                                                               |
+| `widget`  | AdSense, archives, categories, follow.it, links, recent posts, email subscription, tags, table of contents                                                                                                                             |
+| `plugin`  | Baidu Analytics, Bing Webmaster, Busuanzi, CNZZ, cookie consent, gallery, Google Analytics, Hotjar, KaTeX, MathJax, Matomo, outdated browser warning, progress bar, StatCounter, Twitter conversion tracking, Umami, Waline page views |
+| `misc`    | Article licensing, meta tags, Open Graph, paginator, structured data, web app                                                                                                                                                          |
+| `common`  | Article media (a thumbnail with a title and date)                                                                                                                                                                                      |
+
+The components below are deprecated because their services have shut down or are shutting down. They print
+a warning when they are rendered, and will be removed in the next major version.
+
+| Component                | Reason                                                                         | Alternatives               |
+| ------------------------ | ------------------------------------------------------------------------------ | -------------------------- |
+| `share/addthis`          | AddThis shut down on May 31, 2023.                                             | AddToAny, ShareThis        |
+| `comment/gitment`        | Gitment is no longer maintained, and its GitHub sign-in proxy no longer works. | Giscus, Utterances, Gitalk |
+| `comment/valine`         | LeanCloud, where Valine stores the comments, shuts down on January 12, 2027.   | Waline, Twikoo             |
+| `widget/subscribe_email` | Google FeedBurner stopped email subscriptions in July 2021.                    | follow.it                  |
+
+The [API documentation](https://ppoffice.github.io/hexo-component-inferno/) lists the props of every
+component and the options of every module.
+
+## Development
+
+```sh
+npm install
+npm run build         # compile src/ to lib/
+npm test              # run the tests in lib/ (build first)
+npm run test-cov      # run the tests with coverage
+npm run lint          # ESLint
+npm run format-check  # Prettier; `npm run format` fixes it
+npm run docs          # generate the API documentation in doc/
+```
+
+Tests sit next to the source files (`*.test.js` / `*.test.jsx`) and run against the compiled files in
+`lib/`, so run `npm run build` after changing `src/`.
+
+The tests use Hexo 8, which needs Node.js 20.19 or later. CI also tests Node.js 14 with Hexo 7.
 
-Please refer to [this page](https://ppoffice.github.io/hexo-component-inferno/).
+Releases are published to npm by GitHub Actions when a GitHub release is published.
 
-## Examples
+## License
 
-Please refer to tests in the `src` directory or take a look at [hexo-theme-icarus](https://github.com/ppoffice/hexo-theme-icarus).
+[MIT](LICENSE)

package/asset/js/algolia.js

@@ -1,6 +1,28 @@
 /* global instantsearch, algoliasearch */
 // eslint-disable-next-line no-unused-vars
 function loadAlgolia(config, translation) {
+  function escapeHTML(text) {
+    return String(text).replace(/[&<>"']/g, (char) => {
+      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[char];
+    });
+  }
+
+  // Keep the <em> highlights of Algolia, and escape the rest, so that a record cannot add HTML. The
+  // excerpt is indexed from HTML, so its tags are removed.
+  function highlighted(html, stripTags) {
+    html = html
+      .replace(/<em>/gi, '[algolia-highlight]')
+      .replace(/<\/em>/gi, '[/algolia-highlight]');
+    if (stripTags) {
+      html = html.replace(/<[^>]+>/g, '');
+    }
+    return html
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/\[algolia-highlight\]/g, '<em>')
+      .replace(/\[\/algolia-highlight\]/g, '</em>');
+  }
+
   const search = instantsearch({
     indexName: config.indexName,
     searchClient: algoliasearch(config.applicationId, config.apiKey),
@@ -43,21 +65,16 @@ function loadAlgolia(config, translation) {
       },
       templates: {
         empty: function (results) {
-          return translation.no_result + ': ' + results.query;
+          return escapeHTML(translation.no_result + ': ' + results.query);
         },
         item: function (hit) {
           let title = instantsearch.highlight({ attribute: 'title', hit });
           let excerpt = instantsearch.highlight({ attribute: config.excerpt, hit });
-          title = title ? title : translation.untitled;
-          excerpt = excerpt
-            .replace(new RegExp('<em>', 'ig'), '[algolia-highlight]')
-            .replace(new RegExp('</em>', 'ig'), '[/algolia-highlight]')
-            .replace(/(<([^>]+)>)/gi, '')
-            .replace(/(\[algolia-highlight\])/gi, '<em>')
-            .replace(/(\[\/algolia-highlight\])/gi, '</em>');
-          excerpt = excerpt ? excerpt : translation.empty_preview;
+          title = title ? highlighted(title, false) : escapeHTML(translation.untitled);
+          excerpt = highlighted(excerpt, true);
+          excerpt = excerpt ? excerpt : escapeHTML(translation.empty_preview);
           return `<section class="searchbox-result-section">
-                        <a class="searchbox-result-item" href="${hit.permalink}">
+                        <a class="searchbox-result-item" href="${escapeHTML(hit.permalink)}">
                             <span class="searchbox-result-content">
                                 <span class="searchbox-result-title">${title}</span>
                                 <span class="searchbox-result-preview">${excerpt}</span>

package/asset/js/insight.js

@@ -27,18 +27,33 @@ function loadInsight(config, translation) {
     return result;
   }
 
+  // The search content is plain text, so escape it before showing it as HTML
+  function escapeHTML(text) {
+    return text.replace(/[&<>"']/g, (char) => {
+      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[char];
+    });
+  }
+
+  function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
   function findAndHighlight(text, matches, maxlen) {
-    if (!Array.isArray(matches) || !matches.length || !text) {
-      return maxlen ? text.slice(0, maxlen) : text;
+    if (!text) {
+      return text;
+    }
+    if (!Array.isArray(matches) || !matches.length) {
+      return escapeHTML(maxlen ? text.slice(0, maxlen) : text);
     }
-    const testText = text.toLowerCase();
     const indices = matches
       .map((match) => {
-        const index = testText.indexOf(match.toLowerCase());
-        if (!match || index === -1) {
+        // Match the original text case-insensitively, as the lowercase of some characters, such as
+        // "İ", is longer, and its indices would not fit the original text
+        const found = match ? new RegExp(escapeRegExp(match), 'i').exec(text) : null;
+        if (!found) {
           return null;
         }
-        return [index, index + match.length];
+        return [found.index, found.index + found[0].length];
       })
       .filter((match) => {
         return match !== null;
@@ -48,7 +63,7 @@ function loadInsight(config, translation) {
       });
 
     if (!indices.length) {
-      return text;
+      return escapeHTML(maxlen ? text.slice(0, maxlen) : text);
     }
 
     let result = '';
@@ -61,17 +76,21 @@ function loadInsight(config, translation) {
 
     for (let i = 0; i < ranges.length; i++) {
       const range = ranges[i];
-      result += text.slice(last, Math.min(range[0], sumRange[0] + maxlen));
+      result += escapeHTML(
+        text.slice(last, maxlen ? Math.min(range[0], sumRange[0] + maxlen) : range[0]),
+      );
       if (maxlen && range[0] >= sumRange[0] + maxlen) {
         break;
       }
-      result += '<em>' + text.slice(range[0], range[1]) + '</em>';
+      result += '<em>' + escapeHTML(text.slice(range[0], range[1])) + '</em>';
       last = range[1];
       if (i === ranges.length - 1) {
         if (maxlen) {
-          result += text.slice(range[1], Math.min(text.length, sumRange[0] + maxlen + 1));
+          result += escapeHTML(
+            text.slice(range[1], Math.min(text.length, sumRange[0] + maxlen + 1)),
+          );
         } else {
-          result += text.slice(range[1]);
+          result += escapeHTML(text.slice(range[1]));
         }
       }
     }
@@ -80,12 +99,12 @@ function loadInsight(config, translation) {
   }
 
   function searchItem(icon, title, slug, preview, url) {
-    title = title != null && title !== '' ? title : translation.untitled;
+    title = title != null && title !== '' ? title : escapeHTML(translation.untitled);
     const subtitle = slug
       ? '<span class="searchbox-result-title-secondary">(' + slug + ')</span>'
       : '';
 
-    return `<a class="searchbox-result-item" href="${url}">
+    return `<a class="searchbox-result-item" href="${escapeHTML(url)}">
             <span class="searchbox-result-icon">
                 <i class="fa fa-${icon}"></i>
             </span>
@@ -188,17 +207,24 @@ function loadInsight(config, translation) {
   function weight(keywords, obj, fields, weights) {
     let value = 0;
     parseKeywords(keywords).forEach((keyword) => {
-      const pattern = new RegExp(keyword, 'img'); // Global, Multi-line, Case-insensitive
       fields.forEach((field, index) => {
         if (Object.prototype.hasOwnProperty.call(obj, field)) {
-          const matches = obj[field].match(pattern);
-          value += matches ? matches.length * weights[index] : 0;
+          value += countMatches(obj[field].toLowerCase(), keyword) * weights[index];
         }
       });
     });
     return value;
   }
 
+  // Count the occurrences of a lowercase keyword, which is plain text, not a regular expression
+  function countMatches(text, keyword) {
+    let count = 0;
+    for (let i = text.indexOf(keyword); i !== -1; i = text.indexOf(keyword, i + keyword.length)) {
+      count++;
+    }
+    return count;
+  }
+
   function weightFactory(keywords) {
     return {
       post: function (obj) {
@@ -216,38 +242,30 @@ function loadInsight(config, translation) {
     };
   }
 
+  // Weigh each matching item once, instead of in every comparison of the sort
+  function topItems(items, filter, weigh) {
+    return items
+      .filter(filter)
+      .map((item) => {
+        return { item, weight: weigh(item) };
+      })
+      .sort((a, b) => {
+        return b.weight - a.weight;
+      })
+      .slice(0, 5)
+      .map((result) => {
+        return result.item;
+      });
+  }
+
   function search(json, keywords) {
     const weights = weightFactory(keywords);
     const filters = filterFactory(keywords);
-    const posts = json.posts;
-    const pages = json.pages;
-    const tags = json.tags;
-    const categories = json.categories;
     return {
-      posts: posts
-        .filter(filters.post)
-        .sort((a, b) => {
-          return weights.post(b) - weights.post(a);
-        })
-        .slice(0, 5),
-      pages: pages
-        .filter(filters.page)
-        .sort((a, b) => {
-          return weights.page(b) - weights.page(a);
-        })
-        .slice(0, 5),
-      categories: categories
-        .filter(filters.category)
-        .sort((a, b) => {
-          return weights.category(b) - weights.category(a);
-        })
-        .slice(0, 5),
-      tags: tags
-        .filter(filters.tag)
-        .sort((a, b) => {
-          return weights.tag(b) - weights.tag(a);
-        })
-        .slice(0, 5),
+      posts: topItems(json.posts, filters.post, weights.post),
+      pages: topItems(json.pages, filters.page, weights.page),
+      categories: topItems(json.categories, filters.category, weights.category),
+      tags: topItems(json.tags, filters.tag, weights.tag),
     };
   }
 

package/lib/core/migrate.js

@@ -4,6 +4,23 @@
  */
 const semver = require('semver');
 
+/**
+ * Convert the version of a configuration to a semantic version. A version written in a YAML file can
+ * be a number, such as 4.1, or have fewer than three parts.
+ *
+ * @private
+ * @param {string|number} version The version of a configuration.
+ * @returns {string} The semantic version.
+ * @throws {Error} The version is not a version number.
+ */
+function normalizeVersion(version) {
+  const valid = semver.valid(String(version)) || semver.valid(semver.coerce(String(version)));
+  if (!valid) {
+    throw new Error(`${version} is not a valid configuration version`);
+  }
+  return valid;
+}
+
 /**
  * Configuration migration base class.
  * <p>
@@ -72,7 +89,7 @@ class Migrator {
         throw new Error(`Migration ${migration.constructor.name} is not a Migration class.`);
       }
       if (!semver.valid(migration.version)) {
-        throw new Error(`${migration.version} is not a valid version in ${migration.constructor.name}}`);
+        throw new Error(`${migration.version} is not a valid version in ${migration.constructor.name}`);
       }
       this.versions.push(migration.version);
       this.migrations[migration.version] = migration;
@@ -100,7 +117,7 @@ class Migrator {
    * @returns {boolean} true if the given version is the latest version.
    */
   isOudated(version) {
-    return this.getLatestVersion() && semver.lt(version, this.getLatestVersion());
+    return this.getLatestVersion() && semver.lt(normalizeVersion(version), this.getLatestVersion());
   }
 
   /**
@@ -114,15 +131,17 @@ class Migrator {
    * @returns {Object} The upgrade configuration object.
    */
   migrate(config, toVersion = null, callback = null) {
-    const fVer = config.version;
+    const fVer = normalizeVersion(config.version);
     const tVer = toVersion || this.getLatestVersion();
     // find all migrations whose version is larger than fromVer, smaller or equal to toVer
     // and run migrations on the config one by one.
     return this.versions.filter(ver => semver.gt(ver, fVer) && !semver.gt(ver, tVer)).sort(semver.compare).reduce((cfg, ver) => {
       const migration = this.migrations[ver.toString()];
+      // Upgrades can change the version of the given object, so get it before
+      const fromVersion = cfg.version;
       const result = migration.migrate(cfg);
       if (typeof callback === 'function') {
-        callback(cfg.version, migration.version);
+        callback(fromVersion, migration.version);
       }
       return result;
     }, config);

package/lib/core/schema.js

@@ -11,6 +11,15 @@ const yaml = require('../util/yaml');
  */
 const MAGIC = 'c823d4d4';
 
+/**
+ * Deep copy a value of a JSON schema definition, so that changing a default value does not change the
+ * definition, which other schemas may refer to.
+ * @private
+ */
+function copy(value) {
+  return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+
 /**
  * Default value for the primitive types.
  * @access private
@@ -210,8 +219,23 @@ class DefaultValue {
    * @returns {string} The formatted YAML string.
    */
   toYaml() {
-    const regex = new RegExp("^(\\s*)(?:-\\s*\\')?" + MAGIC + ".*?:\\s*\\'?(.*?)\\'*$", 'mg');
-    return yaml.stringify(this.toCommented()).replace(regex, '$1# $2'); // restore comments
+    // Comments are written as properties or array elements, whose values the YAML writer may quote.
+    // Read them back with the YAML parser, rather than removing the quotes by hand.
+    const property = new RegExp(`^(\\s*)(['"]?)${MAGIC}.*?\\2: (.*)$`);
+    const element = new RegExp(`^(\\s*)- (.*${MAGIC}.*)$`);
+    const comment = (indent, text) => `${indent}# ${text === null || text === undefined ? '' : text}`;
+    return yaml.stringify(this.toCommented()).split('\n').map(line => {
+      let match = property.exec(line);
+      if (match) {
+        return comment(match[1], yaml.parse(match[3]));
+      }
+      match = element.exec(line);
+      if (match) {
+        const text = String(yaml.parse(match[2]));
+        return comment(match[1], text.slice(text.indexOf(': ') + 2));
+      }
+      return line;
+    }).join('\n');
   }
 }
 
@@ -388,13 +412,13 @@ class Schema {
       def = this.def;
     }
     if (hasOwnProperty(def, 'const')) {
-      return new DefaultValue(def.const, def.description);
+      return new DefaultValue(copy(def.const), def.description);
     }
     if (hasOwnProperty(def, 'default')) {
-      return new DefaultValue(def.default, def.description);
+      return new DefaultValue(copy(def.default), def.description);
     }
     if (hasOwnProperty(def, 'examples') && typeOf(def.examples) === 'array' && def.examples.length) {
-      return new DefaultValue(def.examples[0], def.description);
+      return new DefaultValue(copy(def.examples[0]), def.description);
     }
     if (hasOwnProperty(def, 'type') && def.type) {
       return this.getTypedDefaultValue(def);
@@ -474,10 +498,8 @@ class SchemaLoader {
  * @throws {Error} Referred schema not found in any of the resolve directories.
  */
 SchemaLoader.load = (rootSchemaDef, resolveDirs = []) => {
-  if (typeOf(resolveDirs) !== 'array') {
-    resolveDirs = [resolveDirs];
-  }
-  resolveDirs.push(path.join(__dirname, '../schema/'));
+  // A new array, so that the directories of the caller are not changed
+  resolveDirs = [].concat(resolveDirs, path.join(__dirname, '../schema/'));
   const loader = new SchemaLoader();
   loader.addSchema(rootSchemaDef);
   function handler($ref) {

package/lib/core/view.js

@@ -57,7 +57,7 @@ _require.resolve = _resolve;
  * Must be used before {@link module:core/view.require} or {@link module:core/view.resolve}.
  *
  * @static
- * @param {string} hexo Hexo instance.
+ * @param {Hexo} hexo The Hexo instance.
  */
 function init(hexo) {
   themeDir = hexo.theme_dir;

package/lib/hexo/filter/locals.js

@@ -35,9 +35,12 @@ const yaml = require('js-yaml');
  * @param {Hexo} hexo The Hexo instance.
  */
 module.exports = hexo => {
+  // Properties that Hexo sets on pages, rather than the front matter, such as the previous and next
+  // posts that the post generator adds
+  const GENERATED_KEYS = ['prev', 'next', 'canonical_path'];
   const RESERVED_KEYS = {
-    post: Object.keys(hexo.model('Post').schema.paths),
-    page: Object.keys(hexo.model('Page').schema.paths)
+    post: Object.keys(hexo.model('Post').schema.paths).concat(GENERATED_KEYS),
+    page: Object.keys(hexo.model('Page').schema.paths).concat(GENERATED_KEYS)
   };
   function loadLayoutConfig(layout) {
     let config = {};

package/lib/hexo/generator/category.js

@@ -16,7 +16,14 @@ module.exports = function (hexo) {
   hexo.extend.generator.register('category', function (locals) {
     const config = this.config;
     const paginationDir = config.pagination_dir || 'page';
-    const perPage = (config.category_generator ? config.category_generator.per_page : null) || 0;
+    // Like hexo-generator-category, use per_page of the site config without a category_generator one
+    const generatorConfig = config.category_generator || {};
+    let perPage = 10;
+    if (typeof generatorConfig.per_page === 'number') {
+      perPage = generatorConfig.per_page;
+    } else if (typeof config.per_page === 'number') {
+      perPage = config.per_page;
+    }
     const orderBy = (config.category_generator ? config.category_generator.order_by : null) || '-date';
     function findParent(category) {
       let parents = [];

package/lib/hexo/generator/insight.js

@@ -2,7 +2,9 @@
  * Insight search content.json generator.
  * @module hexo/generator/insight
  */
-const util = require('hexo-util');
+const {
+  toPlainText
+} = require('../../util/html');
 
 /**
  * Insight search content.json generator.
@@ -12,27 +14,18 @@ const util = require('hexo-util');
 module.exports = function (hexo) {
   hexo.extend.generator.register('insight', function (locals) {
     const url_for = hexo.extend.helper.get('url_for').bind(this);
-    function escape(str) {
-      return util.escapeHTML(str).trim();
-    }
-    function minify(str) {
-      return util.stripHTML(str).trim().replace(/\n/g, ' ').replace(/\s+/g, ' ').replace(/&#x([\da-fA-F]+);/g, (match, hex) => {
-        return String.fromCharCode(parseInt(hex, 16));
-      }).replace(/&#([\d]+);/g, (match, dec) => {
-        return String.fromCharCode(dec);
-      });
-    }
+    // content.json holds plain text, which the search script escapes when it shows it
     function mapPost(post) {
       return {
-        title: escape(post.title),
-        text: minify(post.content),
+        title: (post.title || '').trim(),
+        text: toPlainText(post.content),
         link: url_for(post.path)
       };
     }
     function mapTag(tag) {
       return {
-        name: escape(tag.name),
-        slug: minify(tag.slug),
+        name: (tag.name || '').trim(),
+        slug: (tag.slug || '').trim(),
         link: url_for(tag.path)
       };
     }