toolcraft 0.0.115 → 0.0.117

package/node_modules/uri-template/lib/grammar.pegjs

@@ -0,0 +1,33 @@
+template
+  = parts:(literal / expression)*
+  { return {type: 'template', parts} }
+
+expression
+  = '{' operator:operator variables:variables '}'
+  { return {type: 'expression', operator, variables} }
+
+operator
+  = [/;.?&+#] / ''
+
+variables
+  = hd:variable rst:(',' v:variable { return v })*
+  { rst.unshift(hd); return rst; }
+
+variable
+  = name:$([a-zA-Z0-9_.%]+) modifier:(substr / listMarker)? extension:extension?
+  { return { type: 'variable', name, modifier, extension } }
+
+listMarker
+  = '*'
+  { return { type: 'explode' } }
+
+substr
+  = ':' digits:$[0-9]+
+  { return { type: 'substr', length: parseInt(digits) } }
+
+literal
+    = value:$[^{]+
+    { return { type: 'literal', value } }
+
+extension
+  = '(' text:$[^)]+ ')' { return text }

package/node_modules/uri-template/lib/index.ts

@@ -0,0 +1,33 @@
+import * as grammar from "./grammar.js";
+import * as AST from "./ast";
+import { expandTemplate } from "./expander";
+
+export type RuleToNode = {
+  template: AST.Template;
+  literal: AST.Literal;
+  expression: AST.Expression;
+  operator: AST.Operator;
+  variables: AST.Variable[];
+  variable: AST.Variable;
+  listMarker: AST.ExplodeModifier;
+  substr: AST.SubstrModifier;
+  extension: string;
+};
+
+export function parse(input: string) {
+  const ast = parseRule(input, "template");
+  return {
+    ast,
+    expand: (values: Record<string, unknown>) => expandTemplate(ast, values),
+    toString: () => AST.toString(ast),
+  };
+}
+
+export function parseRule<StartRule extends keyof RuleToNode>(
+  input: string,
+  startRule = "template" as StartRule
+): RuleToNode[StartRule] {
+  return grammar.parse(input, { startRule }) as RuleToNode[StartRule];
+}
+
+export * from "./expander";

package/node_modules/uri-template/package.json

@@ -0,0 +1,33 @@
+{
+  "author": "Stephen Sugden <me@stephensugden.com> (http://stephensugden.com)",
+  "name": "uri-template",
+  "description": "Parse and expand URI templates as defined by http://tools.ietf.org/html/rfc6570",
+  "version": "2.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/grncdr/uri-template.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepare": "make clean all",
+    "test": "make test"
+  },
+  "dependencies": {
+    "pct-encode": "~1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^16.11.0",
+    "peggy": "^1.2.0",
+    "prettier": "^2.4.1",
+    "typescript": "^4.4.4"
+  },
+  "files": [
+    "dist",
+    "lib",
+    "AUTHORS",
+    "LICENSE",
+    "README.md"
+  ],
+  "license": "MIT"
+}

package/node_modules/uri-template-lite/README.md

@@ -0,0 +1,86 @@
+
+[1]: https://badgen.net/coveralls/c/github/litejs/uri-template-lite
+[2]: https://coveralls.io/r/litejs/uri-template-lite
+[3]: https://badgen.net/packagephobia/install/uri-template-lite
+[4]: https://packagephobia.now.sh/result?p=uri-template-lite
+[5]: https://badgen.net/badge/icon/Buy%20Me%20A%20Tea/orange?icon=kofi&label
+[6]: https://www.buymeacoffee.com/lauriro
+
+[RFC 6570]: http://tools.ietf.org/html/rfc6570
+
+
+URI Template Lite – [![Coverage][1]][2] [![size][3]][4] [![Buy Me A Tea][5]][6]
+=================
+
+URI Template [RFC 6570][] expansion and extraction.
+
+
+Usage
+-----
+
+`npm install uri-template-lite`
+
+```javascript
+var UriTemplate = require("uri-template-lite")
+
+// Call `expand` directly
+var data = {"domain":"example.com", "user":"fred", "query":"mycelium"}
+UriTemplate.expand("http://{domain}/~{user}/foo{?query,number}", data)
+// Returns http://example.com/~fred/foo?query=mycelium
+
+// ..or use `Template` constructor
+var template = new UriTemplate("http://{domain}/~{user}/foo{?query,number}")
+template.expand({"domain":"example.com", "user":"fred", "query":"mycelium", "number": 3})
+// Returns http://example.com/~fred/foo?query=mycelium&number=3
+
+// Extract variables
+template.match("http://example.com/~fred/foo?query=mycelium&number=3")
+// Returns {"domain":"example.com", "user":"fred", "query":"mycelium", "number": "3"}
+
+template.match("http://other.com/?query=mycelium")
+// Returns null
+```
+
+
+
+About error handling
+--------------------
+
+This implementation tries to do a best effort template expansion
+and leaves erroneous expressions in the returned URI
+instead of throwing errors.
+So for example, the incorrect expression
+{unclosed will return {unclosed as output.
+
+
+
+Browser Support
+---------------
+
+It should work IE6 and up but automated testing is currently broken.
+
+-   For older browsers it requires `browser-upgrade-lite` package
+    or other ES5 polyfill.
+-   FF3-4 `escape` should be patched to remove non-standard 2nd param,
+    `browser-upgrade-lite` does that.
+
+
+
+## External links
+
+[GitHub repo](https://github.com/litejs/uri-template-lite) |
+[npm package](https://npmjs.org/package/uri-template-lite) |
+URI Template [RFC 6570][] and
+[Tests](https://github.com/uri-templates/uritemplate-test) |
+[Coveralls coverage][2]  
+[Buy Me A Tea][6]
+
+
+## Licence
+
+Copyright (c) 2014-2022 Lauri Rooden <lauri@rooden.ee>  
+[The MIT License](http://lauri.rooden.ee/mit-license.txt)
+
+
+
+

package/node_modules/uri-template-lite/index.js

@@ -0,0 +1,140 @@
+/* global escape */
+
+
+/*! litejs.com/MIT-LICENSE.txt */
+
+
+!function() {
+	"use strict";
+
+	module.exports = Template
+	module.exports.expand = expand
+
+	/**
+	 * URI Template
+	 * @see http://tools.ietf.org/html/rfc6570
+	 */
+
+	var RESERVED = /[!'()]/g
+	// /[[\]:\/!#$&()*+,;='?@]/g
+	, SEPARATORS = {"": ",", "+": ",", "#": ",", "?": "&"}
+	, escapeRe = /[$-/?[-^{|}]/g
+	, expandRe = /\{([#&+./;?]?)((?:[-\w%.]+(\*|:\d+)?(?:,|(?=})))+)\}/g
+	, parseRe  = RegExp(expandRe.source + "|.[^{]*?", "g")
+
+
+	function encodeNormal(val) {
+		return encodeURIComponent(val).replace(RESERVED, escape)
+	}
+	function catchDecode(str) {
+		try {
+			return decodeURIComponent(str)
+		} catch(e) {
+			return str
+		}
+	}
+
+	function notNull(s) {
+		return s != null
+	}
+
+	function mapCleanJoin(arr, mapFn, joinStr) {
+		arr = arr.map(mapFn).filter(notNull)
+		return arr.length && arr.join(joinStr)
+	}
+
+	function expand(template, data, opts) {
+		return template.replace(expandRe, function(_, op, vals) {
+			var sep = SEPARATORS[op] || op
+			, named = sep == ";" || sep == "&"
+			, enc = op && sep == "," ? encodeURI : opts && opts.encoder || encodeNormal
+			, out = mapCleanJoin(vals.split(","), function(_name) {
+				var mod = _name.split(/[*:]/)
+				, name = mod[0]
+				, val = data[name]
+
+				if (val == null) return
+
+				if (typeof val == "object") {
+					mod = name != _name
+					if (Array.isArray(val)) {
+						val = mapCleanJoin(val, enc, mod ? named ? sep + name + "=" : sep : "," )
+					} else {
+						val = mapCleanJoin(Object.keys(val), function(key) {
+							return enc(key) + (mod ? "=" : ",") + enc(val[key])
+						}, mod && (named || sep == "/") ? sep : ",")
+						if (mod) named = 0
+					}
+					if (!val) return
+				} else {
+					val = enc(mod[1] ? val.slice(0, mod[1]) : val)
+				}
+
+				return (
+					named ?
+					name + (val || sep == "&" ? "=" + val : val) :
+					val
+				)
+			}, sep)
+
+			return out || out === "" ? (op != "+" ? op + out : out) : ""
+		}
+	)}
+
+
+	function Template(template, opts_) {
+		var self = this
+		//if (!(self instanceof Template)) return new Template(template)
+		, opts = Object.assign({
+			decoder: catchDecode
+		}, opts_)
+		, pos = 0
+		, lengths = {}
+		, fnStr = ""
+		, reStr = "^" + template.replace(parseRe, function(_, op, vals) {
+			if (!vals) return escapeRegExp(_)
+
+			var sep = SEPARATORS[op] || op
+			, named = sep == ";" || sep == "&"
+			return vals.split(",").map(function(_name, i) {
+				var mod = _name.split(/[*:]/)
+				, name = mod[0]
+				, re = (lengths[name] || "(") + ".*?)"
+
+				pos++
+				if (mod[1]) {
+					re = "((?:%..|.){1," + mod[1] + "})"
+					lengths[name] = "(\\" + pos
+				}
+				fnStr += "t=($[" + pos + "]||'').split('" + (mod[1] ? named ? sep + name + "=" : sep : ",") + "').map(d);"
+				fnStr += "o[\"" + name + "\"]=" + (mod[1] === "" ? "t;" : "t.length>1?t:t[0];")
+				re = escapeRegExp(i === 0 ? op === "+" ? "" : op : sep) + (
+					named ?
+					escapeRegExp(name) + "(?:=" + re + ")?" :
+					//sep == "&" ?
+					//escapeRegExp(name + "=") + re :
+					re
+				)
+				return mod[1] === "" ? "(?:" + re + ")?" : re
+			}).join("")
+		}) + "$"
+		, re = RegExp(reStr)
+		, fn = Function("$,d", "var t,o={};" + fnStr + "return o")
+
+		self.template = template
+		self.match = function(uri) {
+			var match = re.exec(uri)
+			return match && fn(match, opts.decoder)
+		}
+
+		function escapeRegExp(string) {
+			return string.replace(escapeRe, "\\$&")
+		}
+		self.expand = function(data) {
+			return expand(template, data, opts)
+		}
+	}
+
+// `this` is `exports` in NodeJS and `window` in browser.
+}(); // jshint ignore:line
+

package/node_modules/uri-template-lite/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "uri-template-lite",
+  "version": "23.4.0",
+  "license": "MIT",
+  "author": "Lauri Rooden <lauri@rooden.ee>",
+  "description": "URI Template [RFC 6570] expansion and extraction",
+  "keywords": [
+    "uri",
+    "url",
+    "template",
+    "uri-template",
+    "rfc6570",
+    "litejs"
+  ],
+  "main": "index.js",
+  "files": [],
+  "scripts": {
+    "test": "lj test --coverage --brief test/index.js && jshint *.js",
+    "test-fast": "lj test --brief test/index.js"
+  },
+  "repository": "github:litejs/uri-template-lite",
+  "devDependencies": {
+    "@litejs/cli": "23.4.3",
+    "jshint": "2.13.6"
+  },
+  "litejs": {
+    "build": false,
+    "global": false
+  },
+  "jshintConfig": {
+    "esversion": 5,
+    "asi": true,
+    "evil": true,
+    "laxcomma": true,
+    "maxdepth": 6,
+    "node": true,
+    "nonbsp": true,
+    "undef": true,
+    "unused": true,
+    "shadow": "outer",
+    "quotmark": "double"
+  }
+}

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+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/node_modules/yaml/README.md

@@ -0,0 +1,172 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a definitive library for [YAML](https://yaml.org/), the human friendly data serialization standard.
+This library:
+
+- Supports both YAML 1.1 and YAML 1.2 and all common data schemas,
+- Passes all of the [yaml-test-suite](https://github.com/yaml/yaml-test-suite) tests,
+- Can accept any string as input without throwing, parsing as much YAML out of it as it can, and
+- Supports parsing, modifying, and writing YAML comments and blank lines.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/).
+It has no external dependencies and runs on Node.js as well as modern browsers.
+
+For the purposes of versioning, any changes that break any of the documented endpoints or APIs will be considered semver-major breaking changes.
+Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+The minimum supported TypeScript version of the included typings is 3.9;
+for use in earlier versions you may need to set `skipLibCheck: true` in your config.
+This requirement may be updated between minor versions of the library.
+
+For more information, see the project's documentation site: [**eemeli.org/yaml**](https://eemeli.org/yaml/)
+
+For build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+To install:
+
+```sh
+npm install yaml
+# or
+deno add jsr:@eemeli/yaml
+```
+
+**Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the underlying [Lexer/Parser/Composer](https://eemeli.org/yaml/#parsing-yaml).
+The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing.
+
+A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
+
+### Parse & Stringify
+
+```js
+import { parse, stringify } from 'yaml'
+```
+
+- [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
+- [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
+
+### Documents
+
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
+- [`Document`](https://eemeli.org/yaml/#documents)
+  - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
+  - [`#contents`](https://eemeli.org/yaml/#content-nodes)
+  - [`#directives`](https://eemeli.org/yaml/#stream-directives)
+  - [`#errors`](https://eemeli.org/yaml/#errors)
+  - [`#warnings`](https://eemeli.org/yaml/#errors)
+- [`isDocument(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`parseAllDocuments(str, options?): Document[]`](https://eemeli.org/yaml/#parsing-documents)
+- [`parseDocument(str, options?): Document`](https://eemeli.org/yaml/#parsing-documents)
+
+### Content Nodes
+
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
+- [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isNode(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isPair(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isScalar(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isSeq(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
+- [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
+- [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+
+### Parsing YAML
+
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: |
+//   two
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" alt="BrowserStack" />
+</a>

package/node_modules/yaml/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})

package/node_modules/yaml/browser/dist/compose/compose-collection.js

@@ -0,0 +1,88 @@
+import { isNode } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveBlockMap } from './resolve-block-map.js';
+import { resolveBlockSeq } from './resolve-block-seq.js';
+import { resolveFlowCollection } from './resolve-flow-collection.js';
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt?.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = isNode(res)
+        ? res
+        : new Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+export { composeCollection };