toolcraft 0.0.117 → 0.0.119

package/node_modules/uri-template/dist/index.d.ts

@@ -1,19 +0,0 @@
-import * as AST from "./ast";
-export declare 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 declare function parse(input: string): {
-    ast: AST.Template;
-    expand: (values: Record<string, unknown>) => string;
-    toString: () => string;
-};
-export declare function parseRule<StartRule extends keyof RuleToNode>(input: string, startRule?: StartRule): RuleToNode[StartRule];
-export * from "./expander";

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

@@ -1,43 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-exports.__esModule = true;
-exports.parseRule = exports.parse = void 0;
-var grammar = __importStar(require("./grammar.js"));
-var AST = __importStar(require("./ast"));
-var expander_1 = require("./expander");
-function parse(input) {
-    var ast = parseRule(input, "template");
-    return {
-        ast: ast,
-        expand: function (values) { return (0, expander_1.expandTemplate)(ast, values); },
-        toString: function () { return AST.toString(ast); }
-    };
-}
-exports.parse = parse;
-function parseRule(input, startRule) {
-    if (startRule === void 0) { startRule = "template"; }
-    return grammar.parse(input, { startRule: startRule });
-}
-exports.parseRule = parseRule;
-__exportStar(require("./expander"), exports);

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

@@ -1,59 +0,0 @@
-import { abort } from "process";
-
-export interface Template {
-  type: "template";
-  parts: (Literal | Expression)[];
-}
-
-export interface Literal {
-  type: "literal";
-  value: string;
-}
-
-export interface Expression {
-  type: "expression";
-  operator: Operator;
-  variables: Variable[];
-}
-
-export type Operator = "/" | ";" | "." | "?" | "&" | "+" | "#" | "";
-
-export interface Variable {
-  type: "variable";
-  name: string;
-  modifier?: SubstrModifier | ExplodeModifier;
-  extension?: string;
-}
-
-export interface ExplodeModifier {
-  type: "explode";
-}
-
-export interface SubstrModifier {
-  type: "substr";
-  length: number;
-}
-
-export function toString(
-  node: Template | Literal | Expression | Variable
-): string {
-  switch (node.type) {
-    case "template":
-      return node.parts.map(toString).join("");
-    case "literal":
-      return node.value;
-    case "expression":
-      return `{${node.operator}${node.variables.map(toString).join(",")}}`;
-    case "variable":
-      let out = node.name;
-      if (node.modifier?.type == "explode") {
-        out += "*";
-      } else if (node.modifier?.type == "substr") {
-        out += `:${node.modifier.length}`;
-      }
-      if (node.extension) {
-        out += `(${node.extension})`;
-      }
-      return out;
-  }
-}

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

@@ -1,175 +0,0 @@
-import { Template, Expression, Operator, Variable } from "./ast";
-
-import pctEncode from "pct-encode";
-import { abort } from "process";
-
-const encoders = {
-  UrlSafe: pctEncode(/[^\w~.-]/g),
-  Restricted: pctEncode(/[^\w.~:\/\?#\[\]@!\$&'()*+,;=%-]|%(?!\d\d)/g),
-};
-
-export function expandTemplate(
-  ast: Template,
-  values: Record<string, unknown>
-): string {
-  const strings = ast.parts.map((part) => {
-    switch (part.type) {
-      case "literal":
-        return part.value;
-      case "expression":
-        return expandExpression(part, values);
-    }
-  });
-  return strings.join("");
-}
-
-interface ExpansionConfig {
-  first: string;
-  sep: string;
-  empty: string;
-  named: boolean;
-  encode: (s: string) => string;
-}
-
-const defaults: ExpansionConfig = {
-  first: "",
-  sep: ",",
-  empty: "",
-  encode: encoders.UrlSafe,
-  named: false,
-};
-
-const OperatorConfigs: { [op in Operator]: ExpansionConfig } = {
-  "": { ...defaults },
-  "+": { ...defaults, encode: encoders.Restricted },
-  "#": { ...defaults, encode: encoders.Restricted, first: "#", empty: "#" },
-  "/": { ...defaults, first: "/", sep: "/" },
-  ".": { ...defaults, first: ".", sep: ".", empty: "." },
-  ";": { ...defaults, first: ";", sep: ";", named: true },
-  "?": { ...defaults, first: "?", sep: "&", empty: "=", named: true },
-  "&": { ...defaults, first: "&", sep: "&", empty: "=", named: true },
-};
-
-export function expandExpression(
-  expression: Expression,
-  values: Record<string, unknown>
-): string {
-  const config = OperatorConfigs[expression.operator];
-
-  const strings: string[] = [];
-  expression.variables.forEach((variable) => {
-    const value = values[variable.name];
-    if (!present(value)) return;
-    const string = expandVariable(variable, value, config);
-    strings.push(string || "");
-  });
-  if (strings.length === 0) {
-    return "";
-  }
-  const expanded = strings.join(config.sep);
-  if (expanded.length === 0) {
-    return config.empty;
-  }
-  return config.first + expanded;
-}
-
-function expandVariable(
-  variable: Variable,
-  value: unknown,
-  config: ExpansionConfig
-): string | undefined {
-  if (value == null) {
-    throw new TypeError(
-      `tried to expand null value for variable ${variable.name}, this is a bug in uri-template`
-    );
-  }
-  if (variable.modifier?.type === "explode") {
-    return expandValueExplode(variable, value, config);
-  } else {
-    return expandValueSingle(variable, value, config);
-  }
-}
-
-function expandValueSingle(
-  variable: Variable,
-  value: unknown,
-  { empty, encode, named }: ExpansionConfig
-): string {
-  if (typeof value === "object" && variable.modifier?.type === "substr") {
-    throw new Error(
-      "Prefixed variables do not support lists/maps. Check " + variable.name
-    );
-  }
-  let out;
-  if (Array.isArray(value)) {
-    out = value.map(encode).join(",");
-  } else if (typeof value === "object") {
-    out = Object.entries(value as object)
-      .map((entry) => entry.map(encode).join(","))
-      .join(",");
-  } else {
-    out = (value as string).toString();
-    if (variable.modifier?.type === "substr") {
-      out = out.substring(0, variable.modifier.length);
-    }
-    out = encode(out);
-  }
-  if (named) {
-    if (out) {
-      out = `${variable.name}=${out}`;
-    } else {
-      out = `${variable.name}${empty}`;
-    }
-  }
-  return out;
-}
-
-function expandValueExplode(
-  variable: Variable,
-  value: unknown,
-  { encode, named, sep }: ExpansionConfig
-): string {
-  if (Array.isArray(value)) {
-    let items = value.map(encode);
-    if (named) {
-      items = items.map((item) => `${variable.name}=${item}`);
-    }
-    return items.join(sep);
-  } else if (typeof value === "object") {
-    const pairs: string[] = [];
-    Object.entries(value as object).forEach(([k, v]) => {
-      k = encode(k);
-      if (Array.isArray(v)) {
-        v.forEach((item) => {
-          pairs.push(`${k}=${encode(item)}`);
-        });
-      } else {
-        pairs.push(`${k}=${encode(v)}`);
-      }
-    });
-    return pairs.join(sep);
-  } else {
-    const s = (value as string).toString();
-    return encode(s);
-  }
-}
-
-function present(v: unknown): boolean {
-  switch (typeof v) {
-    case "undefined":
-      return false;
-    case "object":
-      if (v == null) {
-        return false;
-      }
-      if (Array.isArray(v)) {
-        return v.length > 0;
-      }
-      for (const k in v) {
-        if ((v as Record<string, unknown>)[k] != null) return true;
-      }
-      return false;
-    default:
-      return true;
-  }
-}