@azuro-org/images-generator 0.0.2 → 0.0.4

package/foo/node_modules/json-parse-even-better-errors/README.md

@@ -1,96 +0,0 @@
-# json-parse-even-better-errors
-
-[`json-parse-even-better-errors`](https://github.com/npm/json-parse-even-better-errors)
-is a Node.js library for getting nicer errors out of `JSON.parse()`,
-including context and position of the parse errors.
-
-It also preserves the newline and indentation styles of the JSON data, by
-putting them in the object or array in the `Symbol.for('indent')` and
-`Symbol.for('newline')` properties.
-
-## Install
-
-`$ npm install --save json-parse-even-better-errors`
-
-## Table of Contents
-
-* [Example](#example)
-* [Features](#features)
-* [Contributing](#contributing)
-* [API](#api)
-  * [`parse`](#parse)
-
-### Example
-
-```javascript
-const parseJson = require('json-parse-even-better-errors')
-
-parseJson('"foo"') // returns the string 'foo'
-parseJson('garbage') // more useful error message
-parseJson.noExceptions('garbage') // returns undefined
-```
-
-### Features
-
-* Like JSON.parse, but the errors are better.
-* Strips a leading byte-order-mark that you sometimes get reading files.
-* Has a `noExceptions` method that returns undefined rather than throwing.
-* Attaches the newline character(s) used to the `Symbol.for('newline')`
-  property on objects and arrays.
-* Attaches the indentation character(s) used to the `Symbol.for('indent')`
-  property on objects and arrays.
-
-## Indentation
-
-To preserve indentation when the file is saved back to disk, use
-`data[Symbol.for('indent')]` as the third argument to `JSON.stringify`, and
-if you want to preserve windows `\r\n` newlines, replace the `\n` chars in
-the string with `data[Symbol.for('newline')]`.
-
-For example:
-
-```js
-const txt = await readFile('./package.json', 'utf8')
-const data = parseJsonEvenBetterErrors(txt)
-const indent = Symbol.for('indent')
-const newline = Symbol.for('newline')
-// .. do some stuff to the data ..
-const string = JSON.stringify(data, null, data[indent]) + '\n'
-const eolFixed = data[newline] === '\n' ? string
-  : string.replace(/\n/g, data[newline])
-await writeFile('./package.json', eolFixed)
-```
-
-Indentation is determined by looking at the whitespace between the initial
-`{` and `[` and the character that follows it.  If you have lots of weird
-inconsistent indentation, then it won't track that or give you any way to
-preserve it.  Whether this is a bug or a feature is debatable ;)
-
-### API
-
-#### <a name="parse"></a> `parse(txt, reviver = null, context = 20)`
-
-Works just like `JSON.parse`, but will include a bit more information when
-an error happens, and attaches a `Symbol.for('indent')` and
-`Symbol.for('newline')` on objects and arrays.  This throws a
-`JSONParseError`.
-
-#### <a name="parse"></a> `parse.noExceptions(txt, reviver = null)`
-
-Works just like `JSON.parse`, but will return `undefined` rather than
-throwing an error.
-
-#### <a name="jsonparseerror"></a> `class JSONParseError(er, text, context = 20, caller = null)`
-
-Extends the JavaScript `SyntaxError` class to parse the message and provide
-better metadata.
-
-Pass in the error thrown by the built-in `JSON.parse`, and the text being
-parsed, and it'll parse out the bits needed to be helpful.
-
-`context` defaults to 20.
-
-Set a `caller` function to trim internal implementation details out of the
-stack trace.  When calling `parseJson`, this is set to the `parseJson`
-function.  If not set, then the constructor defaults to itself, so the
-stack trace will point to the spot where you call `new JSONParseError`.

package/foo/node_modules/json-parse-even-better-errors/index.js

@@ -1,121 +0,0 @@
-'use strict'
-
-const hexify = char => {
-  const h = char.charCodeAt(0).toString(16).toUpperCase()
-  return '0x' + (h.length % 2 ? '0' : '') + h
-}
-
-const parseError = (e, txt, context) => {
-  if (!txt) {
-    return {
-      message: e.message + ' while parsing empty string',
-      position: 0,
-    }
-  }
-  const badToken = e.message.match(/^Unexpected token (.) .*position\s+(\d+)/i)
-  const errIdx = badToken ? +badToken[2]
-    : e.message.match(/^Unexpected end of JSON.*/i) ? txt.length - 1
-    : null
-
-  const msg = badToken ? e.message.replace(/^Unexpected token ./, `Unexpected token ${
-      JSON.stringify(badToken[1])
-    } (${hexify(badToken[1])})`)
-    : e.message
-
-  if (errIdx !== null && errIdx !== undefined) {
-    const start = errIdx <= context ? 0
-      : errIdx - context
-
-    const end = errIdx + context >= txt.length ? txt.length
-      : errIdx + context
-
-    const slice = (start === 0 ? '' : '...') +
-      txt.slice(start, end) +
-      (end === txt.length ? '' : '...')
-
-    const near = txt === slice ? '' : 'near '
-
-    return {
-      message: msg + ` while parsing ${near}${JSON.stringify(slice)}`,
-      position: errIdx,
-    }
-  } else {
-    return {
-      message: msg + ` while parsing '${txt.slice(0, context * 2)}'`,
-      position: 0,
-    }
-  }
-}
-
-class JSONParseError extends SyntaxError {
-  constructor (er, txt, context, caller) {
-    context = context || 20
-    const metadata = parseError(er, txt, context)
-    super(metadata.message)
-    Object.assign(this, metadata)
-    this.code = 'EJSONPARSE'
-    this.systemError = er
-    Error.captureStackTrace(this, caller || this.constructor)
-  }
-  get name () { return this.constructor.name }
-  set name (n) {}
-  get [Symbol.toStringTag] () { return this.constructor.name }
-}
-
-const kIndent = Symbol.for('indent')
-const kNewline = Symbol.for('newline')
-// only respect indentation if we got a line break, otherwise squash it
-// things other than objects and arrays aren't indented, so ignore those
-// Important: in both of these regexps, the $1 capture group is the newline
-// or undefined, and the $2 capture group is the indent, or undefined.
-const formatRE = /^\s*[{\[]((?:\r?\n)+)([\s\t]*)/
-const emptyRE = /^(?:\{\}|\[\])((?:\r?\n)+)?$/
-
-const parseJson = (txt, reviver, context) => {
-  const parseText = stripBOM(txt)
-  context = context || 20
-  try {
-    // get the indentation so that we can save it back nicely
-    // if the file starts with {" then we have an indent of '', ie, none
-    // otherwise, pick the indentation of the next line after the first \n
-    // If the pattern doesn't match, then it means no indentation.
-    // JSON.stringify ignores symbols, so this is reasonably safe.
-    // if the string is '{}' or '[]', then use the default 2-space indent.
-    const [, newline = '\n', indent = '  '] = parseText.match(emptyRE) ||
-      parseText.match(formatRE) ||
-      [, '', '']
-
-    const result = JSON.parse(parseText, reviver)
-    if (result && typeof result === 'object') {
-      result[kNewline] = newline
-      result[kIndent] = indent
-    }
-    return result
-  } catch (e) {
-    if (typeof txt !== 'string' && !Buffer.isBuffer(txt)) {
-      const isEmptyArray = Array.isArray(txt) && txt.length === 0
-      throw Object.assign(new TypeError(
-        `Cannot parse ${isEmptyArray ? 'an empty array' : String(txt)}`
-      ), {
-        code: 'EJSONPARSE',
-        systemError: e,
-      })
-    }
-
-    throw new JSONParseError(e, parseText, context, parseJson)
-  }
-}
-
-// Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
-// because the buffer-to-string conversion in `fs.readFileSync()`
-// translates it to FEFF, the UTF-16 BOM.
-const stripBOM = txt => String(txt).replace(/^\uFEFF/, '')
-
-module.exports = parseJson
-parseJson.JSONParseError = JSONParseError
-
-parseJson.noExceptions = (txt, reviver) => {
-  try {
-    return JSON.parse(stripBOM(txt), reviver)
-  } catch (e) {}
-}

package/foo/node_modules/json-parse-even-better-errors/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "json-parse-even-better-errors",
-  "version": "2.3.1",
-  "description": "JSON.parse with context information on error",
-  "main": "index.js",
-  "files": [
-    "*.js"
-  ],
-  "scripts": {
-    "preversion": "npm t",
-    "postversion": "npm publish",
-    "prepublishOnly": "git push --follow-tags",
-    "test": "tap",
-    "snap": "tap"
-  },
-  "repository": "https://github.com/npm/json-parse-even-better-errors",
-  "keywords": [
-    "JSON",
-    "parser"
-  ],
-  "author": {
-    "name": "Kat Marchán",
-    "email": "kzm@zkat.tech",
-    "twitter": "maybekatz"
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "tap": "^14.6.5"
-  },
-  "tap": {
-    "check-coverage": true
-  }
-}

package/foo/node_modules/lines-and-columns/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Brian Donovan
-
-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/foo/node_modules/lines-and-columns/README.md

@@ -1,33 +0,0 @@
-# lines-and-columns
-
-Maps lines and columns to character offsets and back. This is useful for parsers
-and other text processors that deal in character ranges but process text with
-meaningful lines and columns.
-
-## Install
-
-```
-$ npm install [--save] lines-and-columns
-```
-
-## Usage
-
-```js
-import { LinesAndColumns } from 'lines-and-columns'
-
-const lines = new LinesAndColumns(
-  `table {
-  border: 0
-}`
-)
-
-lines.locationForIndex(9)
-// { line: 1, column: 1 }
-
-lines.indexForLocation({ line: 1, column: 2 })
-// 10
-```
-
-## License
-
-MIT

package/foo/node_modules/lines-and-columns/build/index.d.ts

@@ -1,13 +0,0 @@
-export declare type SourceLocation = {
-    line: number;
-    column: number;
-};
-export declare class LinesAndColumns {
-    private string;
-    private offsets;
-    constructor(string: string);
-    locationForIndex(index: number): SourceLocation | null;
-    indexForLocation(location: SourceLocation): number | null;
-    private lengthOfLine;
-}
-export default LinesAndColumns;

package/foo/node_modules/lines-and-columns/build/index.js

@@ -1,62 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.LinesAndColumns = void 0;
-var LF = '\n';
-var CR = '\r';
-var LinesAndColumns = /** @class */ (function () {
-    function LinesAndColumns(string) {
-        this.string = string;
-        var offsets = [0];
-        for (var offset = 0; offset < string.length;) {
-            switch (string[offset]) {
-                case LF:
-                    offset += LF.length;
-                    offsets.push(offset);
-                    break;
-                case CR:
-                    offset += CR.length;
-                    if (string[offset] === LF) {
-                        offset += LF.length;
-                    }
-                    offsets.push(offset);
-                    break;
-                default:
-                    offset++;
-                    break;
-            }
-        }
-        this.offsets = offsets;
-    }
-    LinesAndColumns.prototype.locationForIndex = function (index) {
-        if (index < 0 || index > this.string.length) {
-            return null;
-        }
-        var line = 0;
-        var offsets = this.offsets;
-        while (offsets[line + 1] <= index) {
-            line++;
-        }
-        var column = index - offsets[line];
-        return { line: line, column: column };
-    };
-    LinesAndColumns.prototype.indexForLocation = function (location) {
-        var line = location.line, column = location.column;
-        if (line < 0 || line >= this.offsets.length) {
-            return null;
-        }
-        if (column < 0 || column > this.lengthOfLine(line)) {
-            return null;
-        }
-        return this.offsets[line] + column;
-    };
-    LinesAndColumns.prototype.lengthOfLine = function (line) {
-        var offset = this.offsets[line];
-        var nextOffset = line === this.offsets.length - 1
-            ? this.string.length
-            : this.offsets[line + 1];
-        return nextOffset - offset;
-    };
-    return LinesAndColumns;
-}());
-exports.LinesAndColumns = LinesAndColumns;
-exports["default"] = LinesAndColumns;

package/foo/node_modules/lines-and-columns/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "lines-and-columns",
-  "version": "1.2.4",
-  "description": "Maps lines and columns to character offsets and back.",
-  "keywords": [
-    "lines",
-    "columns",
-    "parser"
-  ],
-  "homepage": "https://github.com/eventualbuddha/lines-and-columns#readme",
-  "bugs": {
-    "url": "https://github.com/eventualbuddha/lines-and-columns/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/eventualbuddha/lines-and-columns.git"
-  },
-  "license": "MIT",
-  "author": "Brian Donovan <brian@donovans.cc>",
-  "main": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "files": [
-    "build"
-  ],
-  "scripts": {
-    "build:watch": "tsc --build tsconfig.build.json --watch",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "test": "is-ci test:coverage test:watch",
-    "test:coverage": "jest --coverage",
-    "test:watch": "jest --watch"
-  },
-  "devDependencies": {
-    "@types/jest": "^27.0.3",
-    "@types/node": "^16.11.9",
-    "@typescript-eslint/eslint-plugin": "^5.4.0",
-    "@typescript-eslint/parser": "^5.4.0",
-    "esbuild": "^0.13.15",
-    "esbuild-runner": "^2.2.1",
-    "eslint": "^8.2.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "is-ci-cli": "^2.2.0",
-    "jest": "^27.3.1",
-    "prettier": "^2.4.1",
-    "semantic-release": "^18.0.0",
-    "typescript": "^4.5.2"
-  }
-}

package/foo/node_modules/minimatch/LICENSE

@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/foo/node_modules/minimatch/README.md

@@ -1,230 +0,0 @@
-# minimatch
-
-A minimal matching utility.
-
-[![Build Status](https://travis-ci.org/isaacs/minimatch.svg?branch=master)](http://travis-ci.org/isaacs/minimatch)
-
-
-This is the matching library used internally by npm.
-
-It works by converting glob expressions into JavaScript `RegExp`
-objects.
-
-## Usage
-
-```javascript
-var minimatch = require("minimatch")
-
-minimatch("bar.foo", "*.foo") // true!
-minimatch("bar.foo", "*.bar") // false!
-minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
-```
-
-## Features
-
-Supports these glob features:
-
-* Brace Expansion
-* Extended glob matching
-* "Globstar" `**` matching
-
-See:
-
-* `man sh`
-* `man bash`
-* `man 3 fnmatch`
-* `man 5 gitignore`
-
-## Minimatch Class
-
-Create a minimatch object by instantiating the `minimatch.Minimatch` class.
-
-```javascript
-var Minimatch = require("minimatch").Minimatch
-var mm = new Minimatch(pattern, options)
-```
-
-### Properties
-
-* `pattern` The original pattern the minimatch object represents.
-* `options` The options supplied to the constructor.
-* `set` A 2-dimensional array of regexp or string expressions.
-  Each row in the
-  array corresponds to a brace-expanded pattern.  Each item in the row
-  corresponds to a single path-part.  For example, the pattern
-  `{a,b/c}/d` would expand to a set of patterns like:
-
-        [ [ a, d ]
-        , [ b, c, d ] ]
-
-    If a portion of the pattern doesn't have any "magic" in it
-    (that is, it's something like `"foo"` rather than `fo*o?`), then it
-    will be left as a string rather than converted to a regular
-    expression.
-
-* `regexp` Created by the `makeRe` method.  A single regular expression
-  expressing the entire pattern.  This is useful in cases where you wish
-  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
-* `negate` True if the pattern is negated.
-* `comment` True if the pattern is a comment.
-* `empty` True if the pattern is `""`.
-
-### Methods
-
-* `makeRe` Generate the `regexp` member if necessary, and return it.
-  Will return `false` if the pattern is invalid.
-* `match(fname)` Return true if the filename matches the pattern, or
-  false otherwise.
-* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
-  filename, and match it against a single row in the `regExpSet`.  This
-  method is mainly for internal use, but is exposed so that it can be
-  used by a glob-walker that needs to avoid excessive filesystem calls.
-
-All other methods are internal, and will be called as necessary.
-
-### minimatch(path, pattern, options)
-
-Main export.  Tests a path against the pattern using the options.
-
-```javascript
-var isJS = minimatch(file, "*.js", { matchBase: true })
-```
-
-### minimatch.filter(pattern, options)
-
-Returns a function that tests its
-supplied argument, suitable for use with `Array.filter`.  Example:
-
-```javascript
-var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
-```
-
-### minimatch.match(list, pattern, options)
-
-Match against the list of
-files, in the style of fnmatch or glob.  If nothing is matched, and
-options.nonull is set, then return a list containing the pattern itself.
-
-```javascript
-var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
-```
-
-### minimatch.makeRe(pattern, options)
-
-Make a regular expression object from the pattern.
-
-## Options
-
-All options are `false` by default.
-
-### debug
-
-Dump a ton of stuff to stderr.
-
-### nobrace
-
-Do not expand `{a,b}` and `{1..3}` brace sets.
-
-### noglobstar
-
-Disable `**` matching against multiple folder names.
-
-### dot
-
-Allow patterns to match filenames starting with a period, even if
-the pattern does not explicitly have a period in that spot.
-
-Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
-is set.
-
-### noext
-
-Disable "extglob" style patterns like `+(a|b)`.
-
-### nocase
-
-Perform a case-insensitive match.
-
-### nonull
-
-When a match is not found by `minimatch.match`, return a list containing
-the pattern itself if this option is set.  When not set, an empty list
-is returned if there are no matches.
-
-### matchBase
-
-If set, then patterns without slashes will be matched
-against the basename of the path if it contains slashes.  For example,
-`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
-
-### nocomment
-
-Suppress the behavior of treating `#` at the start of a pattern as a
-comment.
-
-### nonegate
-
-Suppress the behavior of treating a leading `!` character as negation.
-
-### flipNegate
-
-Returns from negate expressions the same as if they were not negated.
-(Ie, true on a hit, false on a miss.)
-
-### partial
-
-Compare a partial path to a pattern.  As long as the parts of the path that
-are present are not contradicted by the pattern, it will be treated as a
-match.  This is useful in applications where you're walking through a
-folder structure, and don't yet have the full path, but want to ensure that
-you do not walk down paths that can never be a match.
-
-For example,
-
-```js
-minimatch('/a/b', '/a/*/c/d', { partial: true })  // true, might be /a/b/c/d
-minimatch('/a/b', '/**/d', { partial: true })     // true, might be /a/b/.../d
-minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
-```
-
-### allowWindowsEscape
-
-Windows path separator `\` is by default converted to `/`, which
-prohibits the usage of `\` as a escape character. This flag skips that
-behavior and allows using the escape character.
-
-## Comparisons to other fnmatch/glob implementations
-
-While strict compliance with the existing standards is a worthwhile
-goal, some discrepancies exist between minimatch and other
-implementations, and are intentional.
-
-If the pattern starts with a `!` character, then it is negated.  Set the
-`nonegate` flag to suppress this behavior, and treat leading `!`
-characters normally.  This is perhaps relevant if you wish to start the
-pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
-characters at the start of a pattern will negate the pattern multiple
-times.
-
-If a pattern starts with `#`, then it is treated as a comment, and
-will not match anything.  Use `\#` to match a literal `#` at the
-start of a line, or set the `nocomment` flag to suppress this behavior.
-
-The double-star character `**` is supported by default, unless the
-`noglobstar` flag is set.  This is supported in the manner of bsdglob
-and bash 4.1, where `**` only has special significance if it is the only
-thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
-`a/**b` will not.
-
-If an escaped pattern has no matches, and the `nonull` flag is set,
-then minimatch.match returns the pattern as-provided, rather than
-interpreting the character escapes.  For example,
-`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
-`"*a?"`.  This is akin to setting the `nullglob` option in bash, except
-that it does not resolve escaped pattern characters.
-
-If brace expansion is not disabled, then it is performed before any
-other interpretation of the glob pattern.  Thus, a pattern like
-`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
-**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
-checked for validity.  Since those two are valid, matching proceeds.