readability_js 0.0.1

data/lib/readability_js/node/node_modules/bidi-js/src/mirroring.js

@@ -0,0 +1,48 @@
+import data from './data/bidiMirroring.data.js'
+import { parseCharacterMap } from './util/parseCharacterMap.js'
+
+let mirrorMap
+
+function parse () {
+  if (!mirrorMap) {
+    //const start = performance.now()
+    const { map, reverseMap } = parseCharacterMap(data, true)
+    // Combine both maps into one
+    reverseMap.forEach((value, key) => {
+      map.set(key, value)
+    })
+    mirrorMap = map
+    //console.log(`mirrored chars parsed in ${performance.now() - start}ms`)
+  }
+}
+
+export function getMirroredCharacter (char) {
+  parse()
+  return mirrorMap.get(char) || null
+}
+
+/**
+ * Given a string and its resolved embedding levels, build a map of indices to replacement chars
+ * for any characters in right-to-left segments that have defined mirrored characters.
+ * @param string
+ * @param embeddingLevels
+ * @param [start]
+ * @param [end]
+ * @return {Map<number, string>}
+ */
+export function getMirroredCharactersMap(string, embeddingLevels, start, end) {
+  let strLen = string.length
+  start = Math.max(0, start == null ? 0 : +start)
+  end = Math.min(strLen - 1, end == null ? strLen - 1 : +end)
+
+  const map = new Map()
+  for (let i = start; i <= end; i++) {
+    if (embeddingLevels[i] & 1) { //only odd (rtl) levels
+      const mirror = getMirroredCharacter(string[i])
+      if (mirror !== null) {
+        map.set(i, mirror)
+      }
+    }
+  }
+  return map
+}

data/lib/readability_js/node/node_modules/bidi-js/src/reordering.js

@@ -0,0 +1,99 @@
+import { getBidiCharType, TRAILING_TYPES } from './charTypes.js'
+import { getMirroredCharacter } from './mirroring.js'
+
+/**
+ * Given a start and end denoting a single line within a string, and a set of precalculated
+ * bidi embedding levels, produce a list of segments whose ordering should be flipped, in sequence.
+ * @param {string} string - the full input string
+ * @param {GetEmbeddingLevelsResult} embeddingLevelsResult - the result object from getEmbeddingLevels
+ * @param {number} [start] - first character in a subset of the full string
+ * @param {number} [end] - last character in a subset of the full string
+ * @return {number[][]} - the list of start/end segments that should be flipped, in order.
+ */
+export function getReorderSegments(string, embeddingLevelsResult, start, end) {
+  let strLen = string.length
+  start = Math.max(0, start == null ? 0 : +start)
+  end = Math.min(strLen - 1, end == null ? strLen - 1 : +end)
+
+  const segments = []
+  embeddingLevelsResult.paragraphs.forEach(paragraph => {
+    const lineStart = Math.max(start, paragraph.start)
+    const lineEnd = Math.min(end, paragraph.end)
+    if (lineStart < lineEnd) {
+      // Local slice for mutation
+      const lineLevels = embeddingLevelsResult.levels.slice(lineStart, lineEnd + 1)
+
+      // 3.4 L1.4: Reset any sequence of whitespace characters and/or isolate formatting characters at the
+      // end of the line to the paragraph level.
+      for (let i = lineEnd; i >= lineStart && (getBidiCharType(string[i]) & TRAILING_TYPES); i--) {
+        lineLevels[i] = paragraph.level
+      }
+
+      // L2. From the highest level found in the text to the lowest odd level on each line, including intermediate levels
+      // not actually present in the text, reverse any contiguous sequence of characters that are at that level or higher.
+      let maxLevel = paragraph.level
+      let minOddLevel = Infinity
+      for (let i = 0; i < lineLevels.length; i++) {
+        const level = lineLevels[i]
+        if (level > maxLevel) maxLevel = level
+        if (level < minOddLevel) minOddLevel = level | 1
+      }
+      for (let lvl = maxLevel; lvl >= minOddLevel; lvl--) {
+        for (let i = 0; i < lineLevels.length; i++) {
+          if (lineLevels[i] >= lvl) {
+            const segStart = i
+            while (i + 1 < lineLevels.length && lineLevels[i + 1] >= lvl) {
+              i++
+            }
+            if (i > segStart) {
+              segments.push([segStart + lineStart, i + lineStart])
+            }
+          }
+        }
+      }
+    }
+  })
+  return segments
+}
+
+/**
+ * @param {string} string
+ * @param {GetEmbeddingLevelsResult} embedLevelsResult
+ * @param {number} [start]
+ * @param {number} [end]
+ * @return {string} the new string with bidi segments reordered
+ */
+export function getReorderedString(string, embedLevelsResult, start, end) {
+  const indices = getReorderedIndices(string, embedLevelsResult, start, end)
+  const chars = [...string]
+  indices.forEach((charIndex, i) => {
+    chars[i] = (
+      (embedLevelsResult.levels[charIndex] & 1) ? getMirroredCharacter(string[charIndex]) : null
+    ) || string[charIndex]
+  })
+  return chars.join('')
+}
+
+/**
+ * @param {string} string
+ * @param {GetEmbeddingLevelsResult} embedLevelsResult
+ * @param {number} [start]
+ * @param {number} [end]
+ * @return {number[]} an array with character indices in their new bidi order
+ */
+export function getReorderedIndices(string, embedLevelsResult, start, end) {
+  const segments = getReorderSegments(string, embedLevelsResult, start, end)
+  // Fill an array with indices
+  const indices = []
+  for (let i = 0; i < string.length; i++) {
+    indices[i] = i
+  }
+  // Reverse each segment in order
+  segments.forEach(([start, end]) => {
+    const slice = indices.slice(start, end + 1)
+    for (let i = slice.length; i--;) {
+      indices[end - i] = slice[i]
+    }
+  })
+  return indices
+}

data/lib/readability_js/node/node_modules/bidi-js/src/util/parseCharacterMap.js

@@ -0,0 +1,30 @@
+/**
+ * Parses an string that holds encoded codepoint mappings, e.g. for bracket pairs or
+ * mirroring characters, as encoded by scripts/generateBidiData.js. Returns an object
+ * holding the `map`, and optionally a `reverseMap` if `includeReverse:true`.
+ * @param {string} encodedString
+ * @param {boolean} includeReverse - true if you want reverseMap in the output
+ * @return {{map: Map<number, number>, reverseMap?: Map<number, number>}}
+ */
+export function parseCharacterMap (encodedString, includeReverse) {
+  const radix = 36
+  let lastCode = 0
+  const map = new Map()
+  const reverseMap = includeReverse && new Map()
+  let prevPair
+  encodedString.split(',').forEach(function visit(entry) {
+    if (entry.indexOf('+') !== -1) {
+      for (let i = +entry; i--;) {
+        visit(prevPair)
+      }
+    } else {
+      prevPair = entry
+      let [a, b] = entry.split('>')
+      a = String.fromCodePoint(lastCode += parseInt(a, radix))
+      b = String.fromCodePoint(lastCode += parseInt(b, radix))
+      map.set(a, b)
+      includeReverse && reverseMap.set(b, a)
+    }
+  })
+  return { map, reverseMap }
+}

data/lib/readability_js/node/node_modules/css-tree/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2016-2024 by Roman Dvornov
+
+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.

data/lib/readability_js/node/node_modules/css-tree/README.md

@@ -0,0 +1,192 @@
+<img align="right" width="111" height="111" alt="CSSTree logo" src="assets/csstree-logo-rounded.svg" />
+
+# CSSTree
+
+[![NPM version](https://img.shields.io/npm/v/css-tree.svg)](https://www.npmjs.com/package/css-tree)
+[![Build Status](https://github.com/csstree/csstree/actions/workflows/build.yml/badge.svg)](https://github.com/csstree/csstree/actions/workflows/build.yml)
+[![Coverage Status](https://coveralls.io/repos/github/csstree/csstree/badge.svg?branch=master)](https://coveralls.io/github/csstree/csstree?branch=master)
+[![NPM Downloads](https://img.shields.io/npm/dm/css-tree.svg)](https://www.npmjs.com/package/css-tree)
+[![Twitter](https://img.shields.io/badge/Twitter-@csstree-blue.svg)](https://twitter.com/csstree)
+
+CSSTree is a tool set for CSS: [fast](https://github.com/postcss/benchmark) detailed parser (CSS → AST), walker (AST traversal), generator (AST → CSS) and lexer (validation and matching) based on specs and browser implementations. The main goal is to be efficient and W3C spec compliant, with focus on CSS analyzing and source-to-source transforming tasks.
+
+## Features
+
+- **Detailed parsing with an adjustable level of detail**
+
+  By default CSSTree parses CSS as detailed as possible, i.e. each single logical part is representing with its own AST node (see [AST format](docs/ast.md) for all possible node types). The parsing detail level can be changed through [parser options](docs/parsing.md#parsesource-options), for example, you can disable parsing of selectors or declaration values for component parts.
+
+- **Tolerant to errors by design**
+
+  Parser behaves as [spec says](https://www.w3.org/TR/css-syntax-3/#error-handling): "When errors occur in CSS, the parser attempts to recover gracefully, throwing away only the minimum amount of content before returning to parsing as normal". The only thing the parser departs from the specification is that it doesn't throw away bad content, but wraps it in a special node type (`Raw`) that allows processing it later.
+
+- **Fast and efficient**
+
+  CSSTree is created with focus on performance and effective memory consumption. Therefore it's [one of the fastest CSS parsers](https://github.com/postcss/benchmark) at the moment.
+
+- **Syntax validation**
+
+  The built-in lexer can test CSS against syntaxes defined by W3C. CSSTree uses [mdn/data](https://github.com/mdn/data/) as a basis for lexer's dictionaries and extends it with vendor specific and legacy syntaxes. Lexer can only check the declaration values and at-rules currently, but this feature will be extended to other parts of the CSS in the future.
+
+## Projects using CSSTree
+
+- [Svelte](https://github.com/sveltejs/svelte) – Cybernetically enhanced web apps
+- [SVGO](https://github.com/svg/svgo) – Node.js tool for optimizing SVG files
+- [CSSO](https://github.com/css/csso) – CSS minifier with structural optimizations
+- [NativeScript](https://github.com/NativeScript/NativeScript) – NativeScript empowers you to access native APIs from JavaScript directly
+- [react-native-svg](https://github.com/react-native-svg/react-native-svg) – SVG library for React Native, React Native Web, and plain React web projects
+- [penthouse](https://github.com/pocketjoso/penthouse) – Critical Path CSS Generator
+- [Bit](https://github.com/teambit/bit) – Bit is the platform for collaborating on components
+- and more...
+
+## Documentation
+
+- [AST format](docs/ast.md)
+- [Parsing CSS → AST](docs/parsing.md)
+  - [parse(source[, options])](docs/parsing.md#parsesource-options)
+- [Serialization AST → CSS](docs/generate.md)
+  - [generate(ast[, options])](docs/generate.md#generateast-options)
+- [AST traversal](docs/traversal.md)
+  - [walk(ast, options)](docs/traversal.md#walkast-options)
+  - [find(ast, fn)](docs/traversal.md#findast-fn)
+  - [findLast(ast, fn)](docs/traversal.md#findlastast-fn)
+  - [findAll(ast, fn)](docs/traversal.md#findallast-fn)
+- [Util functions](docs/utils.md)
+  - Value encoding & decoding
+    - [property(name)](docs/utils.md#propertyname)
+    - [keyword(name)](docs/utils.md#keywordname)
+    - [ident](docs/utils.md#ident)
+    - [string](docs/utils.md#string)
+    - [url](docs/utils.md#url)
+  - [List class](docs/list.md)
+  - AST transforming
+    - [clone(ast)](docs/utils.md#cloneast)
+    - [fromPlainObject(object)](docs/utils.md#fromplainobjectobject)
+    - [toPlainObject(ast)](docs/utils.md#toplainobjectast)
+- [Value Definition Syntax](docs/definition-syntax.md)
+  - [parse(source)](docs/definition-syntax.md#parsesource)
+  - [walk(node, options, context)](docs/definition-syntax.md#walknode-options-context)
+  - [generate(node, options)](docs/definition-syntax.md#generatenode-options)
+  - [AST format](docs/definition-syntax.md#ast-format)
+
+## Tools
+
+* [AST Explorer](https://astexplorer.net/#/gist/244e2fb4da940df52bf0f4b94277db44/e79aff44611020b22cfd9708f3a99ce09b7d67a8) – explore CSSTree AST format with zero setup
+* [CSS syntax reference](https://csstree.github.io/docs/syntax.html)
+* [CSS syntax validator](https://csstree.github.io/docs/validator.html)
+
+## Related projects
+
+* [csstree-validator](https://github.com/csstree/validator) – NPM package to validate CSS
+* [stylelint-csstree-validator](https://github.com/csstree/stylelint-validator) – plugin for stylelint to validate CSS
+* [Grunt plugin](https://github.com/sergejmueller/grunt-csstree-validator)
+* [Gulp plugin](https://github.com/csstree/gulp-csstree)
+* [Sublime plugin](https://github.com/csstree/SublimeLinter-contrib-csstree)
+* [VS Code plugin](https://github.com/csstree/vscode-plugin)
+* [Atom plugin](https://github.com/csstree/atom-plugin)
+
+## Usage
+
+Install with npm:
+
+```
+npm install css-tree
+```
+
+Basic usage:
+
+```js
+import * as csstree from 'css-tree';
+
+// parse CSS to AST
+const ast = csstree.parse('.example { world: "!" }');
+
+// traverse AST and modify it
+csstree.walk(ast, (node) => {
+    if (node.type === 'ClassSelector' && node.name === 'example') {
+        node.name = 'hello';
+    }
+});
+
+// generate CSS from AST
+console.log(csstree.generate(ast));
+// .hello{world:"!"}
+```
+
+Syntax matching:
+
+```js
+// parse CSS to AST as a declaration value
+const ast = csstree.parse('red 1px solid', { context: 'value' });
+
+// match to syntax of `border` property
+const matchResult = csstree.lexer.matchProperty('border', ast);
+
+// check first value node is a <color>
+console.log(matchResult.isType(ast.children.first, 'color'));
+// true
+
+// get a type list matched to a node
+console.log(matchResult.getTrace(ast.children.first));
+// [ { type: 'Property', name: 'border' },
+//   { type: 'Type', name: 'color' },
+//   { type: 'Type', name: 'named-color' },
+//   { type: 'Keyword', name: 'red' } ]
+```
+
+### Exports
+
+Is it possible to import just a needed part of library like a parser or a walker. That's might useful for loading time or bundle size optimisations. 
+
+```js
+import * as tokenizer from 'css-tree/tokenizer';
+import * as parser from 'css-tree/parser';
+import * as walker from 'css-tree/walker';
+import * as lexer from 'css-tree/lexer';
+import * as definitionSyntax from 'css-tree/definition-syntax';
+import * as data from 'css-tree/definition-syntax-data';
+import * as dataPatch from 'css-tree/definition-syntax-data-patch';
+import * as utils from 'css-tree/utils';
+```
+
+### Using in a browser
+
+Bundles are available for use in a browser:
+
+- `dist/csstree.js` – minified IIFE with `csstree` as global
+```html
+<script src="node_modules/css-tree/dist/csstree.js"></script>
+<script>
+  csstree.parse('.example { color: green }');
+</script>
+```
+
+- `dist/csstree.esm.js` – minified ES module
+```html
+<script type="module">
+  import { parse } from 'node_modules/css-tree/dist/csstree.esm.js'
+  parse('.example { color: green }');
+</script>
+```
+
+One of CDN services like `unpkg` or `jsDelivr` can be used. By default (for short path) a ESM version is exposing. For IIFE version a full path to a bundle should be specified:
+
+```html
+<!-- ESM -->
+<script type="module">
+  import * as csstree from 'https://cdn.jsdelivr.net/npm/css-tree';
+  import * as csstree from 'https://unpkg.com/css-tree';
+</script>
+
+<!-- IIFE with an export to global -->
+<script src="https://cdn.jsdelivr.net/npm/css-tree/dist/csstree.js"></script>
+<script src="https://unpkg.com/css-tree/dist/csstree.js"></script>
+```
+
+## Top level API
+
+![API map](https://cdn.rawgit.com/csstree/csstree/aaf327e/docs/api-map.svg)
+
+## License
+
+MIT

data/lib/readability_js/node/node_modules/css-tree/cjs/convertor/create.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+const List = require('../utils/List.cjs');
+
+function createConvertor(walk) {
+    return {
+        fromPlainObject(ast) {
+            walk(ast, {
+                enter(node) {
+                    if (node.children && node.children instanceof List.List === false) {
+                        node.children = new List.List().fromArray(node.children);
+                    }
+                }
+            });
+
+            return ast;
+        },
+        toPlainObject(ast) {
+            walk(ast, {
+                leave(node) {
+                    if (node.children && node.children instanceof List.List) {
+                        node.children = node.children.toArray();
+                    }
+                }
+            });
+
+            return ast;
+        }
+    };
+}
+
+exports.createConvertor = createConvertor;

data/lib/readability_js/node/node_modules/css-tree/cjs/convertor/index.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+const create = require('./create.cjs');
+const index$1 = require('../walker/index.cjs');
+
+const index = create.createConvertor(index$1);
+
+module.exports = index;

data/lib/readability_js/node/node_modules/css-tree/cjs/data-patch.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const patch = require('../data/patch.json');
+
+const patch$1 = patch;
+
+module.exports = patch$1;

data/lib/readability_js/node/node_modules/css-tree/cjs/data.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+const dataPatch = require('./data-patch.cjs');
+
+const mdnAtrules = require('mdn-data/css/at-rules.json');
+const mdnProperties = require('mdn-data/css/properties.json');
+const mdnSyntaxes = require('mdn-data/css/syntaxes.json');
+
+const hasOwn = Object.hasOwn || ((object, property) => Object.prototype.hasOwnProperty.call(object, property));
+const extendSyntax = /^\s*\|\s*/;
+
+function preprocessAtrules(dict) {
+    const result = Object.create(null);
+
+    for (const [atruleName, atrule] of Object.entries(dict)) {
+        let descriptors = null;
+
+        if (atrule.descriptors) {
+            descriptors = Object.create(null);
+
+            for (const [name, descriptor] of Object.entries(atrule.descriptors)) {
+                descriptors[name] = descriptor.syntax;
+            }
+        }
+
+        result[atruleName.substr(1)] = {
+            prelude: atrule.syntax.trim().replace(/\{(.|\s)+\}/, '').match(/^@\S+\s+([^;\{]*)/)[1].trim() || null,
+            descriptors
+        };
+    }
+
+    return result;
+}
+
+function patchDictionary(dict, patchDict) {
+    const result = Object.create(null);
+
+    // copy all syntaxes for an original dict
+    for (const [key, value] of Object.entries(dict)) {
+        if (value) {
+            result[key] = value.syntax || value;
+        }
+    }
+
+    // apply a patch
+    for (const key of Object.keys(patchDict)) {
+        if (hasOwn(dict, key)) {
+            if (patchDict[key].syntax) {
+                result[key] = extendSyntax.test(patchDict[key].syntax)
+                    ? result[key] + ' ' + patchDict[key].syntax.trim()
+                    : patchDict[key].syntax;
+            } else {
+                delete result[key];
+            }
+        } else {
+            if (patchDict[key].syntax) {
+                result[key] = patchDict[key].syntax.replace(extendSyntax, '');
+            }
+        }
+    }
+
+    return result;
+}
+
+function preprocessPatchAtrulesDescritors(declarations) {
+    const result = {};
+
+    for (const [key, value] of Object.entries(declarations || {})) {
+        result[key] = typeof value === 'string'
+            ? { syntax: value }
+            : value;
+    }
+
+    return result;
+}
+
+function patchAtrules(dict, patchDict) {
+    const result = {};
+
+    // copy all syntaxes for an original dict
+    for (const key in dict) {
+        if (patchDict[key] === null) {
+            continue;
+        }
+
+        const atrulePatch = patchDict[key] || {};
+
+        result[key] = {
+            prelude: key in patchDict && 'prelude' in atrulePatch
+                ? atrulePatch.prelude
+                : dict[key].prelude || null,
+            descriptors: patchDictionary(
+                dict[key].descriptors || {},
+                preprocessPatchAtrulesDescritors(atrulePatch.descriptors)
+            )
+        };
+    }
+
+    // apply a patch
+    for (const [key, atrulePatch] of Object.entries(patchDict)) {
+        if (atrulePatch && !hasOwn(dict, key)) {
+            result[key] = {
+                prelude: atrulePatch.prelude || null,
+                descriptors: atrulePatch.descriptors
+                    ? patchDictionary({}, preprocessPatchAtrulesDescritors(atrulePatch.descriptors))
+                    : null
+            };
+        }
+    }
+
+    return result;
+}
+
+const definitions = {
+    types: patchDictionary(mdnSyntaxes, dataPatch.types),
+    atrules: patchAtrules(preprocessAtrules(mdnAtrules), dataPatch.atrules),
+    properties: patchDictionary(mdnProperties, dataPatch.properties)
+};
+
+module.exports = definitions;

data/lib/readability_js/node/node_modules/css-tree/cjs/definition-syntax/SyntaxError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const createCustomError = require('../utils/create-custom-error.cjs');
+
+function SyntaxError(message, input, offset) {
+    return Object.assign(createCustomError.createCustomError('SyntaxError', message), {
+        input,
+        offset,
+        rawMessage: message,
+        message: message + '\n' +
+            '  ' + input + '\n' +
+            '--' + new Array((offset || input.length) + 1).join('-') + '^'
+    });
+}
+
+exports.SyntaxError = SyntaxError;