@naturalcycles/js-lib 14.107.1 → 14.109.0

package/dist/index.d.ts

@@ -49,6 +49,9 @@ import { pTimeout, pTimeoutFn, PTimeoutOptions } from './promise/pTimeout';
 export * from './string/case';
 export * from './string/json.util';
 export * from './string/string.util';
+export * from './string/readingTime';
+export * from './string/escape';
+export * from './string/pupa';
 import { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './string/stringifyAny';
 export * from './time/time.util';
 export * from './is.util';

package/dist/index.js

@@ -63,6 +63,9 @@ Object.defineProperty(exports, "pTimeoutFn", { enumerable: true, get: function (
 tslib_1.__exportStar(require("./string/case"), exports);
 tslib_1.__exportStar(require("./string/json.util"), exports);
 tslib_1.__exportStar(require("./string/string.util"), exports);
+tslib_1.__exportStar(require("./string/readingTime"), exports);
+tslib_1.__exportStar(require("./string/escape"), exports);
+tslib_1.__exportStar(require("./string/pupa"), exports);
 const stringifyAny_1 = require("./string/stringifyAny");
 Object.defineProperty(exports, "_stringifyAny", { enumerable: true, get: function () { return stringifyAny_1._stringifyAny; } });
 tslib_1.__exportStar(require("./time/time.util"), exports);

package/dist/string/escape.d.ts

@@ -0,0 +1,2 @@
+export declare function htmlEscape(strings: string | TemplateStringsArray, ...values: any[]): string;
+export declare function htmlUnescape(strings: string | TemplateStringsArray, ...values: any[]): string;

package/dist/string/escape.js

@@ -0,0 +1,54 @@
+"use strict";
+/*
+
+Vendored:
+https://github.com/sindresorhus/escape-goat
+
+(c) Sindre Sorhus
+
+Reasons:
+1. Stable enough to be included in "core" js-lib
+2. ESM-only
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlUnescape = exports.htmlEscape = void 0;
+// Multiple `.replace()` calls are actually faster than using replacer functions
+function _htmlEscape(s) {
+    return s
+        .replace(/&/g, '&') // Must happen first or else it will escape other just-escaped characters.
+        .replace(/"/g, '"')
+        .replace(/'/g, ''')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function _htmlUnescape(html) {
+    return html
+        .replace(/&gt;/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&#0?39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&amp;/g, '&'); // Must happen last or else it will unescape other characters in the wrong order.
+}
+function htmlEscape(strings, ...values) {
+    if (typeof strings === 'string') {
+        return _htmlEscape(strings);
+    }
+    let output = strings[0];
+    for (const [index, value] of values.entries()) {
+        output = output + _htmlEscape(String(value)) + strings[index + 1];
+    }
+    return output;
+}
+exports.htmlEscape = htmlEscape;
+function htmlUnescape(strings, ...values) {
+    if (typeof strings === 'string') {
+        return _htmlUnescape(strings);
+    }
+    let output = strings[0];
+    for (const [index, value] of values.entries()) {
+        output = output + _htmlUnescape(String(value)) + strings[index + 1];
+    }
+    return output;
+}
+exports.htmlUnescape = htmlUnescape;

package/dist/string/pupa.d.ts

@@ -0,0 +1,22 @@
+import type { AnyObject } from '../types';
+export declare class MissingValueError extends Error {
+    key: any;
+    constructor(key: any);
+}
+export interface PupaOptions {
+    /**
+     * By default, Pupa throws a `MissingValueError` when a placeholder resolves to `undefined`. With this option set to `true`, it simply ignores it and leaves the placeholder as is.
+     */
+    ignoreMissing?: boolean;
+    /**
+     * Performs arbitrary operation for each interpolation. If the returned value was `undefined`, it behaves differently depending on the `ignoreMissing` option. Otherwise, the returned value will be interpolated into a string (and escaped when double-braced) and embedded into the template.
+     */
+    transform?: (data: {
+        value: any;
+        key: string;
+    }) => unknown;
+}
+/**
+ * API: https://github.com/sindresorhus/pupa
+ */
+export declare function pupa(template: string, data: any[] | AnyObject, opt?: PupaOptions): string;

package/dist/string/pupa.js

@@ -0,0 +1,60 @@
+"use strict";
+/*
+
+Vendored:
+https://github.com/sindresorhus/pupa
+
+(c) Sindre Sorhus
+
+Reasons:
+1. Stable enough to be included in "core" js-lib
+2. ESM-only
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pupa = exports.MissingValueError = void 0;
+const escape_1 = require("./escape");
+class MissingValueError extends Error {
+    constructor(key) {
+        super(`Missing a value for ${key ? `the placeholder: ${key}` : 'a placeholder'}`);
+        this.key = key;
+        this.name = 'MissingValueError';
+        this.key = key;
+    }
+}
+exports.MissingValueError = MissingValueError;
+/**
+ * API: https://github.com/sindresorhus/pupa
+ */
+function pupa(template, data, opt = {}) {
+    if (typeof template !== 'string') {
+        throw new TypeError(`Expected a \`string\` in the first argument, got \`${typeof template}\``);
+    }
+    if (typeof data !== 'object') {
+        throw new TypeError(`Expected an \`object\` or \`Array\` in the second argument, got \`${typeof data}\``);
+    }
+    const { ignoreMissing = false, transform = ({ value }) => value } = opt;
+    const replace = (placeholder, key) => {
+        let value = data;
+        for (const property of key.split('.')) {
+            value = value ? value[property] : undefined;
+        }
+        const transformedValue = transform({ value, key });
+        if (transformedValue === undefined) {
+            if (ignoreMissing) {
+                return placeholder;
+            }
+            throw new MissingValueError(key);
+        }
+        return String(transformedValue);
+    };
+    const composeHtmlEscape = (replacer) => (...args) => (0, escape_1.htmlEscape)(replacer(...args));
+    // The regex tries to match either a number inside `{{ }}` or a valid JS identifier or key path.
+    const doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi;
+    if (doubleBraceRegex.test(template)) {
+        template = template.replace(doubleBraceRegex, composeHtmlEscape(replace));
+    }
+    const braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi;
+    return template.replace(braceRegex, replace);
+}
+exports.pupa = pupa;

package/dist/string/readingTime.d.ts

@@ -0,0 +1,29 @@
+import type { Integer } from '../types';
+export interface ReadingTimeOptions {
+    /**
+     * A function that returns a boolean value depending on if a character is considered as a word bound.
+     * Default: spaces, new lines and tabs
+     */
+    wordBound?: (char: string) => boolean;
+    /**
+     * Default 200
+     */
+    wordsPerMinute?: number;
+}
+export interface ReadingTimeStats {
+    /**
+     * Number of milliseconds.
+     */
+    time: Integer;
+    minutes: Integer;
+}
+export interface WordCountStats {
+    total: number;
+}
+export interface ReadingTimeResult extends ReadingTimeStats {
+    words: WordCountStats;
+}
+/**
+ * API: https://github.com/ngryman/reading-time
+ */
+export declare function readingTime(text: string, options?: ReadingTimeOptions): ReadingTimeResult;

package/dist/string/readingTime.js

@@ -0,0 +1,106 @@
+"use strict";
+/*
+
+Vendored from https://github.com/ngryman/reading-time
+(c) Nicolas Gryman <ngryman@gmail.com>
+
+Reasons:
+1. latest (1.5.0) version had a typescript import bug.
+2. Streaming mode is not needed (but brings confusion when used in the Browser).
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readingTime = void 0;
+function codeIsInRanges(num, arrayOfRanges) {
+    return arrayOfRanges.some(([lowerBound, upperBound]) => lowerBound <= num && num <= upperBound);
+}
+const isCJK = c => {
+    const charCode = c.codePointAt(0);
+    // Help wanted!
+    // This should be good for most cases, but if you find it unsatisfactory
+    // (e.g. some other language where each character should be standalone words),
+    // contributions welcome!
+    return codeIsInRanges(charCode, [
+        // Hiragana (Katakana not included on purpose,
+        // context: https://github.com/ngryman/reading-time/pull/35#issuecomment-853364526)
+        // If you think Katakana should be included and have solid reasons, improvement is welcomed
+        [0x3040, 0x309f],
+        // CJK Unified ideographs
+        [0x4e00, 0x9fff],
+        // Hangul
+        [0xac00, 0xd7a3],
+        // CJK extensions
+        [0x20000, 0x2ebe0],
+    ]);
+};
+const isAnsiWordBound = c => {
+    return ' \n\r\t'.includes(c);
+};
+const isPunctuation = c => {
+    const charCode = c.codePointAt(0);
+    return codeIsInRanges(charCode, [
+        [0x21, 0x2f],
+        [0x3a, 0x40],
+        [0x5b, 0x60],
+        [0x7b, 0x7e],
+        // CJK Symbols and Punctuation
+        [0x3000, 0x303f],
+        // Full-width ASCII punctuation variants
+        [0xff00, 0xffef],
+    ]);
+};
+function countWords(text, options = {}) {
+    let words = 0;
+    let start = 0;
+    let end = text.length - 1;
+    const isWordBound = options.wordBound || isAnsiWordBound;
+    // fetch bounds
+    while (isWordBound(text[start]))
+        start++;
+    while (isWordBound(text[end]))
+        end--;
+    // Add a trailing word bound to make handling edges more convenient
+    const normalizedText = `${text}\n`;
+    // calculate the number of words
+    for (let i = start; i <= end; i++) {
+        // A CJK character is a always word;
+        // A non-word bound followed by a word bound / CJK is the end of a word.
+        if (isCJK(normalizedText[i]) ||
+            (!isWordBound(normalizedText[i]) &&
+                (isWordBound(normalizedText[i + 1]) || isCJK(normalizedText[i + 1])))) {
+            words++;
+        }
+        // In case of CJK followed by punctuations, those characters have to be eaten as well
+        if (isCJK(normalizedText[i])) {
+            while (i <= end &&
+                (isPunctuation(normalizedText[i + 1]) || isWordBound(normalizedText[i + 1]))) {
+                i++;
+            }
+        }
+    }
+    return { total: words };
+}
+function readingTimeWithCount(words, options = {}) {
+    const { wordsPerMinute = 200 } = options;
+    // reading time stats
+    const minutes = words.total / wordsPerMinute;
+    // Math.round used to resolve floating point funkiness
+    //   http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+    const time = Math.round(minutes * 60 * 1000);
+    const displayed = Math.ceil(parseFloat(minutes.toFixed(2)));
+    return {
+        minutes: displayed,
+        time,
+    };
+}
+/**
+ * API: https://github.com/ngryman/reading-time
+ */
+function readingTime(text, options = {}) {
+    const words = countWords(text, options);
+    return {
+        ...readingTimeWithCount(words, options),
+        words,
+    };
+}
+exports.readingTime = readingTime;

package/dist/types.d.ts

@@ -179,19 +179,17 @@ export declare type Reviver = (this: any, key: string, value: any) => any;
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-export declare function _stringMapValues<T>(m: StringMap<T>): T[];
+export declare const _stringMapValues: <T>(m: StringMap<T>) => T[];
 /**
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-export declare function _stringMapEntries<T>(m: StringMap<T>): [k: string, v: T][];
+export declare const _stringMapEntries: <T>(m: StringMap<T>) => [k: string, v: T][];
 /**
  * Like `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
- *
- * @experimental
  */
-export declare function _objectKeys<T extends AnyObject>(obj: T): (keyof T)[];
+export declare const _objectKeys: <T extends AnyObject>(obj: T) => (keyof T)[];
 export declare type NullishValue = null | undefined;
 export declare type FalsyValue = false | '' | 0 | null | undefined;
 /**

package/dist/types.js

@@ -26,28 +26,17 @@ exports._passNothingPredicate = _passNothingPredicate;
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-function _stringMapValues(m) {
-    return Object.values(m);
-}
-exports._stringMapValues = _stringMapValues;
+exports._stringMapValues = Object.values;
 /**
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-function _stringMapEntries(m) {
-    return Object.entries(m);
-}
-exports._stringMapEntries = _stringMapEntries;
+exports._stringMapEntries = Object.entries;
 /**
  * Like `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
- *
- * @experimental
  */
-function _objectKeys(obj) {
-    return Object.keys(obj);
-}
-exports._objectKeys = _objectKeys;
+exports._objectKeys = Object.keys;
 /**
  * Utility function that helps to cast *existing variable* to needed type T.
  *

package/dist-esm/index.js

@@ -46,6 +46,9 @@ import { pTimeout, pTimeoutFn } from './promise/pTimeout';
 export * from './string/case';
 export * from './string/json.util';
 export * from './string/string.util';
+export * from './string/readingTime';
+export * from './string/escape';
+export * from './string/pupa';
 import { _stringifyAny } from './string/stringifyAny';
 export * from './time/time.util';
 export * from './is.util';

package/dist-esm/string/escape.js

@@ -0,0 +1,49 @@
+/*
+
+Vendored:
+https://github.com/sindresorhus/escape-goat
+
+(c) Sindre Sorhus
+
+Reasons:
+1. Stable enough to be included in "core" js-lib
+2. ESM-only
+
+ */
+// Multiple `.replace()` calls are actually faster than using replacer functions
+function _htmlEscape(s) {
+    return s
+        .replace(/&/g, '&') // Must happen first or else it will escape other just-escaped characters.
+        .replace(/"/g, '"')
+        .replace(/'/g, ''')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function _htmlUnescape(html) {
+    return html
+        .replace(/&gt;/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&#0?39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&amp;/g, '&'); // Must happen last or else it will unescape other characters in the wrong order.
+}
+export function htmlEscape(strings, ...values) {
+    if (typeof strings === 'string') {
+        return _htmlEscape(strings);
+    }
+    let output = strings[0];
+    for (const [index, value] of values.entries()) {
+        output = output + _htmlEscape(String(value)) + strings[index + 1];
+    }
+    return output;
+}
+export function htmlUnescape(strings, ...values) {
+    if (typeof strings === 'string') {
+        return _htmlUnescape(strings);
+    }
+    let output = strings[0];
+    for (const [index, value] of values.entries()) {
+        output = output + _htmlUnescape(String(value)) + strings[index + 1];
+    }
+    return output;
+}

package/dist-esm/string/pupa.js

@@ -0,0 +1,55 @@
+/*
+
+Vendored:
+https://github.com/sindresorhus/pupa
+
+(c) Sindre Sorhus
+
+Reasons:
+1. Stable enough to be included in "core" js-lib
+2. ESM-only
+
+ */
+import { htmlEscape } from './escape';
+export class MissingValueError extends Error {
+    constructor(key) {
+        super(`Missing a value for ${key ? `the placeholder: ${key}` : 'a placeholder'}`);
+        this.key = key;
+        this.name = 'MissingValueError';
+        this.key = key;
+    }
+}
+/**
+ * API: https://github.com/sindresorhus/pupa
+ */
+export function pupa(template, data, opt = {}) {
+    if (typeof template !== 'string') {
+        throw new TypeError(`Expected a \`string\` in the first argument, got \`${typeof template}\``);
+    }
+    if (typeof data !== 'object') {
+        throw new TypeError(`Expected an \`object\` or \`Array\` in the second argument, got \`${typeof data}\``);
+    }
+    const { ignoreMissing = false, transform = ({ value }) => value } = opt;
+    const replace = (placeholder, key) => {
+        let value = data;
+        for (const property of key.split('.')) {
+            value = value ? value[property] : undefined;
+        }
+        const transformedValue = transform({ value, key });
+        if (transformedValue === undefined) {
+            if (ignoreMissing) {
+                return placeholder;
+            }
+            throw new MissingValueError(key);
+        }
+        return String(transformedValue);
+    };
+    const composeHtmlEscape = (replacer) => (...args) => htmlEscape(replacer(...args));
+    // The regex tries to match either a number inside `{{ }}` or a valid JS identifier or key path.
+    const doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi;
+    if (doubleBraceRegex.test(template)) {
+        template = template.replace(doubleBraceRegex, composeHtmlEscape(replace));
+    }
+    const braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi;
+    return template.replace(braceRegex, replace);
+}

package/dist-esm/string/readingTime.js

@@ -0,0 +1,99 @@
+/*
+
+Vendored from https://github.com/ngryman/reading-time
+(c) Nicolas Gryman <ngryman@gmail.com>
+
+Reasons:
+1. latest (1.5.0) version had a typescript import bug.
+2. Streaming mode is not needed (but brings confusion when used in the Browser).
+
+ */
+function codeIsInRanges(num, arrayOfRanges) {
+    return arrayOfRanges.some(([lowerBound, upperBound]) => lowerBound <= num && num <= upperBound);
+}
+const isCJK = c => {
+    const charCode = c.codePointAt(0);
+    // Help wanted!
+    // This should be good for most cases, but if you find it unsatisfactory
+    // (e.g. some other language where each character should be standalone words),
+    // contributions welcome!
+    return codeIsInRanges(charCode, [
+        // Hiragana (Katakana not included on purpose,
+        // context: https://github.com/ngryman/reading-time/pull/35#issuecomment-853364526)
+        // If you think Katakana should be included and have solid reasons, improvement is welcomed
+        [0x3040, 0x309f],
+        // CJK Unified ideographs
+        [0x4e00, 0x9fff],
+        // Hangul
+        [0xac00, 0xd7a3],
+        // CJK extensions
+        [0x20000, 0x2ebe0],
+    ]);
+};
+const isAnsiWordBound = c => {
+    return ' \n\r\t'.includes(c);
+};
+const isPunctuation = c => {
+    const charCode = c.codePointAt(0);
+    return codeIsInRanges(charCode, [
+        [0x21, 0x2f],
+        [0x3a, 0x40],
+        [0x5b, 0x60],
+        [0x7b, 0x7e],
+        // CJK Symbols and Punctuation
+        [0x3000, 0x303f],
+        // Full-width ASCII punctuation variants
+        [0xff00, 0xffef],
+    ]);
+};
+function countWords(text, options = {}) {
+    let words = 0;
+    let start = 0;
+    let end = text.length - 1;
+    const isWordBound = options.wordBound || isAnsiWordBound;
+    // fetch bounds
+    while (isWordBound(text[start]))
+        start++;
+    while (isWordBound(text[end]))
+        end--;
+    // Add a trailing word bound to make handling edges more convenient
+    const normalizedText = `${text}\n`;
+    // calculate the number of words
+    for (let i = start; i <= end; i++) {
+        // A CJK character is a always word;
+        // A non-word bound followed by a word bound / CJK is the end of a word.
+        if (isCJK(normalizedText[i]) ||
+            (!isWordBound(normalizedText[i]) &&
+                (isWordBound(normalizedText[i + 1]) || isCJK(normalizedText[i + 1])))) {
+            words++;
+        }
+        // In case of CJK followed by punctuations, those characters have to be eaten as well
+        if (isCJK(normalizedText[i])) {
+            while (i <= end &&
+                (isPunctuation(normalizedText[i + 1]) || isWordBound(normalizedText[i + 1]))) {
+                i++;
+            }
+        }
+    }
+    return { total: words };
+}
+function readingTimeWithCount(words, options = {}) {
+    const { wordsPerMinute = 200 } = options;
+    // reading time stats
+    const minutes = words.total / wordsPerMinute;
+    // Math.round used to resolve floating point funkiness
+    //   http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+    const time = Math.round(minutes * 60 * 1000);
+    const displayed = Math.ceil(parseFloat(minutes.toFixed(2)));
+    return {
+        minutes: displayed,
+        time,
+    };
+}
+/**
+ * API: https://github.com/ngryman/reading-time
+ */
+export function readingTime(text, options = {}) {
+    const words = countWords(text, options);
+    return Object.assign(Object.assign({}, readingTimeWithCount(words, options)), { words });
+}

package/dist-esm/types.js

@@ -18,25 +18,17 @@ export const _passNothingPredicate = () => false;
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-export function _stringMapValues(m) {
-    return Object.values(m);
-}
+export const _stringMapValues = Object.values;
 /**
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-export function _stringMapEntries(m) {
-    return Object.entries(m);
-}
+export const _stringMapEntries = Object.entries;
 /**
  * Like `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
- *
- * @experimental
  */
-export function _objectKeys(obj) {
-    return Object.keys(obj);
-}
+export const _objectKeys = Object.keys;
 /**
  * Utility function that helps to cast *existing variable* to needed type T.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.107.1",
+  "version": "14.109.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -18,12 +18,10 @@
     "@types/node": "^18.0.0",
     "expect-type": "^0.13.0",
     "jest": "^28.0.3",
-    "patch-package": "^6.2.1",
     "prettier": "^2.1.2",
     "rxjs": "^7.0.1",
     "vuepress": "^1.7.1",
-    "vuepress-plugin-typescript": "^0.3.1",
-    "weak-napi": "^2.0.2"
+    "vuepress-plugin-typescript": "^0.3.1"
   },
   "files": [
     "dist",

package/src/index.ts

@@ -82,6 +82,9 @@ import { pTimeout, pTimeoutFn, PTimeoutOptions } from './promise/pTimeout'
 export * from './string/case'
 export * from './string/json.util'
 export * from './string/string.util'
+export * from './string/readingTime'
+export * from './string/escape'
+export * from './string/pupa'
 import { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './string/stringifyAny'
 export * from './time/time.util'
 export * from './is.util'

package/src/string/escape.ts

@@ -0,0 +1,57 @@
+/*
+
+Vendored:
+https://github.com/sindresorhus/escape-goat
+
+(c) Sindre Sorhus
+
+Reasons:
+1. Stable enough to be included in "core" js-lib
+2. ESM-only
+
+ */
+
+// Multiple `.replace()` calls are actually faster than using replacer functions
+function _htmlEscape(s: string): string {
+  return s
+    .replace(/&/g, '&') // Must happen first or else it will escape other just-escaped characters.
+    .replace(/"/g, '"')
+    .replace(/'/g, ''')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}
+
+function _htmlUnescape(html: string): string {
+  return html
+    .replace(/&gt;/g, '>')
+    .replace(/&lt;/g, '<')
+    .replace(/&#0?39;/g, "'")
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, '&') // Must happen last or else it will unescape other characters in the wrong order.
+}
+
+export function htmlEscape(strings: string | TemplateStringsArray, ...values: any[]): string {
+  if (typeof strings === 'string') {
+    return _htmlEscape(strings)
+  }
+
+  let output = strings[0]!
+  for (const [index, value] of values.entries()) {
+    output = output + _htmlEscape(String(value)) + strings[index + 1]
+  }
+
+  return output
+}
+
+export function htmlUnescape(strings: string | TemplateStringsArray, ...values: any[]): string {
+  if (typeof strings === 'string') {
+    return _htmlUnescape(strings)
+  }
+
+  let output = strings[0]!
+  for (const [index, value] of values.entries()) {
+    output = output + _htmlUnescape(String(value)) + strings[index + 1]
+  }
+
+  return output
+}

package/src/string/pupa.ts

@@ -0,0 +1,86 @@
+/*
+
+Vendored:
+https://github.com/sindresorhus/pupa
+
+(c) Sindre Sorhus
+
+Reasons:
+1. Stable enough to be included in "core" js-lib
+2. ESM-only
+
+ */
+
+import type { AnyObject } from '../types'
+import { htmlEscape } from './escape'
+
+export class MissingValueError extends Error {
+  constructor(public key: any) {
+    super(`Missing a value for ${key ? `the placeholder: ${key}` : 'a placeholder'}`)
+    this.name = 'MissingValueError'
+    this.key = key
+  }
+}
+
+export interface PupaOptions {
+  /**
+   * By default, Pupa throws a `MissingValueError` when a placeholder resolves to `undefined`. With this option set to `true`, it simply ignores it and leaves the placeholder as is.
+   */
+  ignoreMissing?: boolean
+
+  /**
+   * Performs arbitrary operation for each interpolation. If the returned value was `undefined`, it behaves differently depending on the `ignoreMissing` option. Otherwise, the returned value will be interpolated into a string (and escaped when double-braced) and embedded into the template.
+   */
+  transform?: (data: { value: any; key: string }) => unknown
+}
+
+/**
+ * API: https://github.com/sindresorhus/pupa
+ */
+export function pupa(template: string, data: any[] | AnyObject, opt: PupaOptions = {}): string {
+  if (typeof template !== 'string') {
+    throw new TypeError(`Expected a \`string\` in the first argument, got \`${typeof template}\``)
+  }
+
+  if (typeof data !== 'object') {
+    throw new TypeError(
+      `Expected an \`object\` or \`Array\` in the second argument, got \`${typeof data}\``,
+    )
+  }
+
+  const { ignoreMissing = false, transform = ({ value }) => value } = opt
+
+  const replace = (placeholder: string, key: string): string => {
+    let value = data
+    for (const property of key.split('.')) {
+      value = value ? (value as AnyObject)[property] : undefined
+    }
+
+    const transformedValue = transform({ value, key })
+    if (transformedValue === undefined) {
+      if (ignoreMissing) {
+        return placeholder
+      }
+
+      throw new MissingValueError(key)
+    }
+
+    return String(transformedValue)
+  }
+
+  const composeHtmlEscape =
+    (replacer: any) =>
+    (...args: any[]) =>
+      htmlEscape(replacer(...args))
+
+  // The regex tries to match either a number inside `{{ }}` or a valid JS identifier or key path.
+  const doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi
+
+  if (doubleBraceRegex.test(template)) {
+    template = template.replace(doubleBraceRegex, composeHtmlEscape(replace))
+  }
+
+  const braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi
+
+  return template.replace(braceRegex, replace)
+}

package/src/string/readingTime.ts

@@ -0,0 +1,150 @@
+/*
+
+Vendored from https://github.com/ngryman/reading-time
+(c) Nicolas Gryman <ngryman@gmail.com>
+
+Reasons:
+1. latest (1.5.0) version had a typescript import bug.
+2. Streaming mode is not needed (but brings confusion when used in the Browser).
+
+ */
+
+import type { Integer } from '../types'
+
+export interface ReadingTimeOptions {
+  /**
+   * A function that returns a boolean value depending on if a character is considered as a word bound.
+   * Default: spaces, new lines and tabs
+   */
+  wordBound?: (char: string) => boolean
+  /**
+   * Default 200
+   */
+  wordsPerMinute?: number
+}
+
+export interface ReadingTimeStats {
+  /**
+   * Number of milliseconds.
+   */
+  time: Integer
+  minutes: Integer
+}
+
+export interface WordCountStats {
+  total: number
+}
+
+export interface ReadingTimeResult extends ReadingTimeStats {
+  words: WordCountStats
+}
+
+type WordBoundFunction = (char: string) => boolean
+
+function codeIsInRanges(num: number, arrayOfRanges: number[][]) {
+  return arrayOfRanges.some(([lowerBound, upperBound]) => lowerBound! <= num && num <= upperBound!)
+}
+
+const isCJK: WordBoundFunction = c => {
+  const charCode = c.codePointAt(0)!
+  // Help wanted!
+  // This should be good for most cases, but if you find it unsatisfactory
+  // (e.g. some other language where each character should be standalone words),
+  // contributions welcome!
+  return codeIsInRanges(charCode, [
+    // Hiragana (Katakana not included on purpose,
+    // context: https://github.com/ngryman/reading-time/pull/35#issuecomment-853364526)
+    // If you think Katakana should be included and have solid reasons, improvement is welcomed
+    [0x3040, 0x309f],
+    // CJK Unified ideographs
+    [0x4e00, 0x9fff],
+    // Hangul
+    [0xac00, 0xd7a3],
+    // CJK extensions
+    [0x20000, 0x2ebe0],
+  ])
+}
+
+const isAnsiWordBound: WordBoundFunction = c => {
+  return ' \n\r\t'.includes(c)
+}
+
+const isPunctuation: WordBoundFunction = c => {
+  const charCode = c.codePointAt(0)!
+  return codeIsInRanges(charCode, [
+    [0x21, 0x2f],
+    [0x3a, 0x40],
+    [0x5b, 0x60],
+    [0x7b, 0x7e],
+    // CJK Symbols and Punctuation
+    [0x3000, 0x303f],
+    // Full-width ASCII punctuation variants
+    [0xff00, 0xffef],
+  ])
+}
+
+function countWords(text: string, options: ReadingTimeOptions = {}): WordCountStats {
+  let words = 0
+  let start = 0
+  let end = text.length - 1
+  const isWordBound = options.wordBound || isAnsiWordBound
+
+  // fetch bounds
+  while (isWordBound(text[start]!)) start++
+  while (isWordBound(text[end]!)) end--
+
+  // Add a trailing word bound to make handling edges more convenient
+  const normalizedText = `${text}\n`
+
+  // calculate the number of words
+  for (let i = start; i <= end; i++) {
+    // A CJK character is a always word;
+    // A non-word bound followed by a word bound / CJK is the end of a word.
+    if (
+      isCJK(normalizedText[i]!) ||
+      (!isWordBound(normalizedText[i]!) &&
+        (isWordBound(normalizedText[i + 1]!) || isCJK(normalizedText[i + 1]!)))
+    ) {
+      words++
+    }
+    // In case of CJK followed by punctuations, those characters have to be eaten as well
+    if (isCJK(normalizedText[i]!)) {
+      while (
+        i <= end &&
+        (isPunctuation(normalizedText[i + 1]!) || isWordBound(normalizedText[i + 1]!))
+      ) {
+        i++
+      }
+    }
+  }
+  return { total: words }
+}
+
+function readingTimeWithCount(
+  words: WordCountStats,
+  options: ReadingTimeOptions = {},
+): ReadingTimeStats {
+  const { wordsPerMinute = 200 } = options
+  // reading time stats
+  const minutes = words.total / wordsPerMinute
+  // Math.round used to resolve floating point funkiness
+  //   http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+  const time = Math.round(minutes * 60 * 1000)
+  const displayed = Math.ceil(parseFloat(minutes.toFixed(2)))
+
+  return {
+    minutes: displayed,
+    time,
+  }
+}
+
+/**
+ * API: https://github.com/ngryman/reading-time
+ */
+export function readingTime(text: string, options: ReadingTimeOptions = {}): ReadingTimeResult {
+  const words = countWords(text, options)
+  return {
+    ...readingTimeWithCount(words, options),
+    words,
+  }
+}

package/src/types.ts

@@ -243,27 +243,19 @@ export type Reviver = (this: any, key: string, value: any) => any
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-export function _stringMapValues<T>(m: StringMap<T>): T[] {
-  return Object.values(m) as T[]
-}
+export const _stringMapValues = Object.values as <T>(m: StringMap<T>) => T[]
 
 /**
  * Needed due to https://github.com/microsoft/TypeScript/issues/13778
  * Only affects typings, no runtime effect.
  */
-export function _stringMapEntries<T>(m: StringMap<T>): [k: string, v: T][] {
-  return Object.entries(m) as [string, T][]
-}
+export const _stringMapEntries = Object.entries as <T>(m: StringMap<T>) => [k: string, v: T][]
 
 /**
  * Like `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
- *
- * @experimental
  */
-export function _objectKeys<T extends AnyObject>(obj: T): (keyof T)[] {
-  return Object.keys(obj)
-}
+export const _objectKeys = Object.keys as <T extends AnyObject>(obj: T) => (keyof T)[]
 
 export type NullishValue = null | undefined
 export type FalsyValue = false | '' | 0 | null | undefined