toiljs 0.0.4 → 0.0.5

package/examples/basic/node_modules/toilscript/util/node.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Node.js polyfills.
+ * @license Apache-2.0
+ */
+
+export const isNode = Object.prototype.toString.call(typeof globalThis.process !== 'undefined' ? globalThis.process : 0) === '[object process]';
+
+var fs;
+var module;
+var path;
+var process;
+var url;
+
+if (isNode) {
+  fs = await import("fs");
+  module = await import("module");
+  path = await import("path");
+  process = globalThis.process;
+  url = await import("url");
+} else {
+  fs = await import("./browser/fs.js");
+  module = await import("./browser/module.js");
+  path = await import("./browser/path.js");
+  process = await import("./browser/process.js");
+  url = await import("./browser/url.js");
+}
+
+export {
+  fs,
+  module,
+  path,
+  process,
+  url
+};

package/examples/basic/node_modules/toilscript/util/options.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Command line options utility definitions.
+ * @license Apache-2.0
+ */
+
+/** A set of options. */
+export interface OptionSet {
+  [key: string]: number | string
+}
+
+/** Command line option description. */
+export interface OptionDescription {
+  /** Textual description. */
+  description?: string | string[],
+  /** Data type. One of (b)oolean [default], (i)nteger, (f)loat or (s)tring. Uppercase means multiple values. */
+  type?: "b" | "i" | "f" | "s" | "I" | "F" | "S",
+  /** Substituted options, if any. */
+  value?: OptionSet,
+  /** Short alias, if any. */
+  alias?: string
+  /** The default value, if any. */
+  default?: string | number | boolean | string[] | number[];
+  /** The category this option belongs in. */
+  category?: string;
+}
+
+/** Configuration object. */
+export interface Config {
+  [key: string]: OptionDescription;
+}
+
+/** Parsing result. */
+export interface Result {
+  /** Parsed options. */
+  options: OptionSet,
+  /** Unknown options. */
+  unknown: string[],
+  /** Normal arguments. */
+  arguments: string[],
+  /** Trailing arguments. */
+  trailing: string[]
+}
+
+/** Parses the specified command line arguments according to the given configuration. */
+export function parse(argv: string[], config: Config, propagateDefaults?: boolean): Result;
+
+/** Help formatting options. */
+export interface HelpOptions {
+  /** Leading indent. Defaults to 2. */
+  indent?: number,
+  /** Table padding. Defaults to 24. */
+  padding?: number,
+  /** End of line character. Defaults to "\n". */
+  eol?: string
+}
+
+/** Generates the help text for the specified configuration. */
+export function help(config: Config, options?: HelpOptions): string;
+
+/** Merges two sets of options into one, preferring the current over the parent set. */
+export function merge(config: Config, currentOptions: OptionSet, parentOptions: OptionSet, parentBaseDir: string): OptionSet;
+
+/** Normalizes a path. */
+export function normalizePath(path: string): string;
+
+/** Resolves a single relative path. Keeps absolute paths, otherwise prepends baseDir. */
+export function resolvePath(path: string, baseDir: string, useNodeResolution?: boolean): string;
+
+/** Populates default values on a parsed options result. */
+export function addDefaults(config: Config, options: OptionSet): void;

package/examples/basic/node_modules/toilscript/util/options.js

@@ -0,0 +1,262 @@
+/**
+ * @fileoverview Command line options utility.
+ * @license Apache-2.0
+ */
+
+import { path, module } from "./node.js";
+import { stdoutColors } from "./terminal.js";
+
+const require = module.createRequire(import.meta.url);
+
+// type | meaning
+// -----|---------------
+// b    | boolean
+// i    | integer
+// f    | float
+// s    | string
+// I    | integer array
+// F    | float array
+// S    | string array
+
+/** Parses the specified command line arguments according to the given configuration. */
+export function parse(argv, config, propagateDefaults = true) {
+  var options = {};
+  var unknown = [];
+  var args = [];
+  var trailing = [];
+
+  // make an alias map and initialize defaults
+  var aliases = {};
+  Object.keys(config).forEach(key => {
+    if (key.startsWith(" ")) return;
+    var option = config[key];
+    if (option.alias != null) {
+      if (typeof option.alias === "string") aliases[option.alias] = key;
+      else if (Array.isArray(option.alias)) option.alias.forEach(alias => aliases[alias] = key);
+    }
+    if (propagateDefaults && option.default != null) options[key] = option.default;
+  });
+
+  // iterate over argv
+  for (var i = 0, k = (argv = argv.slice()).length; i < k; ++i) {
+    let arg = argv[i];
+    if (arg == "--") { ++i; break; }
+    let match = /^(?:(-\w)(?:=(.*))?|(--\w{2,})(?:=(.*))?)$/.exec(arg), option, key;
+    if (match) {
+      if (config[arg]) option = config[key = arg]; // exact
+      else if (match[1] != null) { // alias
+        option = config[key = aliases[match[1].substring(1)]];
+        if (option && match[2] != null) argv[i--] = match[2];
+      } else if (match[3] != null) { // full
+        option = config[key = match[3].substring(2)];
+        if (option && match[4] != null) argv[i--] = match[4];
+      }
+    } else {
+      if (arg.charCodeAt(0) == 45) option = config[key = arg]; // exact
+      else { args.push(arg); continue; } // argument
+    }
+    if (option) {
+      if (option.value) {
+        // alias setting fixed values
+        Object.keys(option.value).forEach(k => options[k] = option.value[k]);
+      } else if (option.type == null || option.type === "b") {
+        // boolean flag not taking a value
+        options[key] = true;
+      } else {
+        if (i + 1 < argv.length && argv[i + 1].charCodeAt(0) != 45) {
+          // non-boolean with given value
+          switch (option.type) {
+            case "i": options[key] = parseInt(argv[++i], 10); break;
+            case "I": options[key] = (options[key] || []).concat(parseInt(argv[++i], 10)); break;
+            case "f": options[key] = parseFloat(argv[++i]); break;
+            case "F": options[key] = (options[key] || []).concat(parseFloat(argv[++i])); break;
+            case "s": options[key] = String(argv[++i]); break;
+            case "S": options[key] = (options[key] || []).concat(argv[++i].split(",")); break;
+            default: unknown.push(arg); --i;
+          }
+        } else {
+          // non-boolean with omitted value
+          switch (option.type) {
+            case "i":
+            case "f": options[key] = option.default || 0; break;
+            case "s": options[key] = option.default || ""; break;
+            case "I":
+            case "F":
+            case "S": options[key] = option.default || []; break;
+            default: unknown.push(arg);
+          }
+        }
+      }
+    } else unknown.push(arg);
+  }
+  while (i < k) trailing.push(argv[i++]); // trailing
+  if (propagateDefaults) addDefaults(config, options);
+
+  return { options, unknown, arguments: args, trailing };
+}
+
+/** Generates the help text for the specified configuration. */
+export function help(config, options) {
+  if (!options) options = {};
+  var indent = options.indent || 2;
+  var padding = options.padding || 24;
+  var eol = options.eol || "\n";
+  var sbCategories = {};
+  var sbOther = [];
+  Object.keys(config).forEach(key => {
+    var option = config[key];
+    if (option.description == null) return;
+    var text = "";
+    while (text.length < indent) text += " ";
+    text += "--" + key;
+    if (option.alias) text += ", -" + option.alias;
+    while (text.length < padding) text += " ";
+    var sb;
+    if (!options.noCategories && option.category) {
+      if (!(sb = sbCategories[option.category])) {
+        sbCategories[option.category] = sb = [];
+      }
+    } else {
+      sb = sbOther;
+    }
+    if (Array.isArray(option.description)) {
+      sb.push(text + option.description[0] + option.description.slice(1).map(line => {
+        for (let i = 0; i < padding; ++i) line = " " + line;
+        return eol + line;
+      }).join(""));
+    } else sb.push(text + option.description);
+  });
+  var sb = [];
+  var hasCategories = false;
+  Object.keys(sbCategories).forEach(category => {
+    hasCategories = true;
+    sb.push(eol + " " + stdoutColors.gray(category) + eol);
+    sb.push(sbCategories[category].join(eol));
+  });
+  if (hasCategories && sbOther.length) {
+    sb.push(eol + " " + stdoutColors.gray("Other") + eol);
+  }
+  sb.push(sbOther.join(eol));
+  return sb.join(eol);
+}
+
+/** Sanitizes an option value to be a valid value of the option's type. */
+function sanitizeValue(value, type) {
+  if (value != null) {
+    switch (type) {
+      case undefined:
+      case "b": return Boolean(value);
+      case "i": return Math.trunc(value) || 0;
+      case "f": return Number(value) || 0;
+      case "s": {
+        if (value === true) return "";
+        if (value === false) return null;
+        return String(value);
+      }
+      case "I": {
+        if (!Array.isArray(value)) value = [ value ];
+        return value.map(v => Math.trunc(v) || 0);
+      }
+      case "F": {
+        if (!Array.isArray(value)) value = [ value ];
+        return value.map(v => Number(v) || 0);
+      }
+      case "S": {
+        if (!Array.isArray(value)) value = [ value ];
+        return value.map(String);
+      }
+    }
+  }
+  return undefined;
+}
+
+/** Merges two sets of options into one, preferring the current over the parent set. */
+export function merge(config, currentOptions, parentOptions, parentBaseDir) {
+  const mergedOptions = {};
+  for (const [key, { type, mutuallyExclusive, isPath, useNodeResolution, cliOnly }] of Object.entries(config)) {
+    let currentValue = sanitizeValue(currentOptions[key], type);
+    let parentValue = sanitizeValue(parentOptions[key], type);
+    if (currentValue == null) {
+      if (parentValue != null) {
+        // only parent value present
+        if (cliOnly) continue;
+        if (Array.isArray(parentValue)) {
+          let exclude;
+          if (isPath) {
+            parentValue = parentValue.map(value => resolvePath(value, parentBaseDir, useNodeResolution));
+          }
+          if (mutuallyExclusive != null && (exclude = currentOptions[mutuallyExclusive])) {
+            mergedOptions[key] = parentValue.filter(value => !exclude.includes(value));
+          } else {
+            mergedOptions[key] = parentValue.slice();
+          }
+        } else {
+          if (isPath) {
+            parentValue = resolvePath(parentValue, parentBaseDir, useNodeResolution);
+          }
+          mergedOptions[key] = parentValue;
+        }
+      }
+    } else if (parentValue == null) {
+      // only current value present
+      if (Array.isArray(currentValue)) {
+        mergedOptions[key] = currentValue.slice();
+      } else {
+        mergedOptions[key] = currentValue;
+      }
+    } else {
+      // both current and parent values present
+      if (Array.isArray(currentValue)) {
+        if (cliOnly) {
+          mergedOptions[key] = currentValue.slice();
+          continue;
+        }
+        let exclude;
+        if (isPath) {
+          parentValue = parentValue.map(value => resolvePath(value, parentBaseDir, useNodeResolution));
+        }
+        if (mutuallyExclusive != null && (exclude = currentOptions[mutuallyExclusive])) {
+          mergedOptions[key] = [
+            ...currentValue,
+            ...parentValue.filter(value => !currentValue.includes(value) && !exclude.includes(value))
+          ];
+        } else {
+          mergedOptions[key] = [
+            ...currentValue,
+            ...parentValue.filter(value => !currentValue.includes(value)) // dedup
+          ];
+        }
+      } else {
+        mergedOptions[key] = currentValue;
+      }
+    }
+  }
+  return mergedOptions;
+}
+
+/** Normalizes a path. */
+export function normalizePath(p) {
+  const parsed = path.parse(p);
+  if (!parsed.root) {
+    parsed.root = "./";
+  }
+  return path.format(parsed);
+}
+
+/** Resolves a single possibly relative path. Keeps absolute paths, otherwise prepends baseDir. */
+export function resolvePath(p, baseDir, useNodeResolution = false) {
+  if (path.isAbsolute(p)) return p;
+  if (useNodeResolution && !p.startsWith(".") && require.resolve) {
+    return require.resolve(p, { paths: [ baseDir ] });
+  }
+  return normalizePath(path.join(baseDir, p));
+}
+
+/** Populates default values on a parsed options result. */
+export function addDefaults(config, options) {
+  for (const [key, { default: defaultValue }] of Object.entries(config)) {
+    if (options[key] == null && defaultValue != null) {
+      options[key] = defaultValue;
+    }
+  }
+}

package/examples/basic/node_modules/toilscript/util/terminal.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Terminal colors utility definitions.
+ * @license Apache-2.0
+ */
+
+/** Color code for gray. */
+export const GRAY: string;
+/** Color code for red. */
+export const RED: string;
+/** Color code for green. */
+export const GREEN: string;
+/** Color code for yellow. */
+export const YELLOW: string;
+/** Color code for blue. */
+export const BLUE: string;
+/** Color code for magenta. */
+export const MAGENTA: string;
+/** Color code for cyan. */
+export const CYAN: string;
+/** Color code for white. */
+export const WHITE: string;
+/** Code to reset any colors. */
+export const RESET: string;
+
+/** Color utility class. */
+export class Colors {
+  /** Constructs a new instance for the given stream. */
+  constructor(stream: { isTTY: boolean });
+  /** Whether terminal colors are enabled. */
+  enabled: boolean;
+  /** Colors a string in gray if {@link enabled}. */
+  gray(text: string): string;
+  /** Colors a string in red if {@link enabled}. */
+  red(text: string): string;
+  /** Colors a string in green if {@link enabled}. */
+  green(text: string): string;
+  /** Colors a string in yellow if {@link enabled}. */
+  yellow(text: string): string;
+  /** Colors a string in blue if {@link enabled}. */
+  blue(text: string): string;
+  /** Colors a string in magenta if {@link enabled}. */
+  magenta(text: string): string;
+  /** Colors a string in cyan if {@link enabled}. */
+  cyan(text: string): string;
+  /** Colors a string in white if {@link enabled}. */
+  white(text: string): string;
+}
+
+/** Color utility for stdout. */
+export const stdoutColors: Colors;
+/** Color utility for stderr. */
+export const stderrColors: Colors;

package/examples/basic/node_modules/toilscript/util/terminal.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Terminal utility.
+ * @license Apache-2.0
+ */
+
+var proc = typeof process !== "undefined" && process || {};
+var isCI = proc.env && "CI" in proc.env;
+
+export const GRAY = "\u001b[90m";
+export const RED = "\u001b[91m";
+export const GREEN = "\u001b[92m";
+export const YELLOW = "\u001b[93m";
+export const BLUE = "\u001b[94m";
+export const MAGENTA = "\u001b[95m";
+export const CYAN = "\u001b[96m";
+export const WHITE = "\u001b[97m";
+export const RESET = "\u001b[0m";
+
+export class Colors {
+  constructor(stream) {
+    this.stream = stream;
+    this.enabled = Boolean((this.stream && this.stream.isTTY) || isCI);
+  }
+  gray(text) { return this.enabled ? GRAY + text + RESET : text; }
+  red(text) { return this.enabled ? RED + text + RESET : text; }
+  green(text) { return this.enabled ? GREEN + text + RESET : text; }
+  yellow(text) { return this.enabled ? YELLOW + text + RESET : text; }
+  blue(text) { return this.enabled ? BLUE + text + RESET : text; }
+  magenta(text) { return this.enabled ? MAGENTA + text + RESET : text; }
+  cyan(text) { return this.enabled ? CYAN + text + RESET : text; }
+  white(text) { return this.enabled ? WHITE + text + RESET : text; }
+}
+
+export const stdoutColors = new Colors(proc.stdout);
+export const stderrColors = new Colors(proc.stderr);

package/examples/basic/node_modules/toilscript/util/text.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Text utility definitions.
+ * @license Apache-2.0
+ */
+
+/** Calculates the UTF-8 byte length of a string. */
+export function utf8Length(string: string): number;
+
+/** Reads UTF-8 bytes as a string. */
+export function utf8Read(buffer: Uint8Array, start: number, end: number): string;
+
+/** Writes a string as UTF-8 bytes. */
+export function utf8Write(string: string, buffer: Uint8Array, offset: number): number;
+
+/** UTF-8 utility. */
+export const utf8: {
+  /** Calculates the UTF8 byte length of a string. */
+  length: typeof utf8Length;
+  /** Reads UTF8 bytes as a string. */
+  read: typeof utf8Read;
+  /** Writes a string as UTF8 bytes. */
+  write: typeof utf8Write;
+};
+
+/** Computes the difference between an expected and its actual text. */
+export function diff(filename: string, expected: string, actual: string): string;

package/examples/basic/node_modules/toilscript/util/text.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Text utility.
+ * @license Apache-2.0
+ */
+
+import * as Diff from "diff";
+import { stdoutColors } from "./terminal.js";
+
+export function utf8Length(string) {
+  var len = 0;
+  for (var i = 0, k = string.length; i < k; ++i) {
+    let c = string.charCodeAt(i);
+    if (c < 128) {
+      len += 1;
+    } else if (c < 2048) {
+      len += 2;
+    } else if ((c & 0xFC00) === 0xD800 && i + 1 < k && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+      ++i;
+      len += 4;
+    } else {
+      len += 3;
+    }
+  }
+  return len;
+}
+
+export function utf8Read(buffer, start, end) {
+  var len = end - start;
+  if (len < 1) return "";
+  var parts = null,
+      chunk = [],
+      i = 0, // char offset
+      t;     // temporary
+  while (start < end) {
+    t = buffer[start++];
+    if (t < 128) {
+      chunk[i++] = t;
+    } else if (t > 191 && t < 224) {
+      chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+    } else if (t > 239 && t < 365) {
+      t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
+      chunk[i++] = 0xD800 + (t >> 10);
+      chunk[i++] = 0xDC00 + (t & 1023);
+    } else {
+      chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+    }
+    if (i >= 8192) {
+      (parts || (parts = [])).push(String.fromCharCode(...chunk));
+      i = 0;
+    }
+  }
+  if (parts) {
+    if (i) parts.push(String.fromCharCode(...chunk.slice(0, i)));
+    return parts.join("");
+  }
+  return String.fromCharCode(...chunk.slice(0, i));
+}
+
+export function utf8Write(string, buffer, offset) {
+  var start = offset;
+  for (var i = 0, k = string.length; i < k; ++i) {
+    let c1 = string.charCodeAt(i), c2;
+    if (c1 < 128) {
+      buffer[offset++] = c1;
+    } else if (c1 < 2048) {
+      buffer[offset++] = c1 >> 6 | 192;
+      buffer[offset++] = c1 & 63 | 128;
+    } else if ((c1 & 0xFC00) === 0xD800 && i + 1 < k && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+      c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+      ++i;
+      buffer[offset++] = c1 >> 18 | 240;
+      buffer[offset++] = c1 >> 12 & 63 | 128;
+      buffer[offset++] = c1 >> 6 & 63 | 128;
+      buffer[offset++] = c1 & 63 | 128;
+    } else {
+      buffer[offset++] = c1 >> 12 | 224;
+      buffer[offset++] = c1 >> 6 & 63 | 128;
+      buffer[offset++] = c1 & 63 | 128;
+    }
+  }
+  return offset - start;
+}
+
+export const utf8 = {
+  length: utf8Length,
+  read: utf8Read,
+  write: utf8Write
+};
+
+export function diff(filename, expected, actual) {
+  const diff = Diff.structuredPatch(filename, filename, expected, actual, "expected", "actual", { context: 5 });
+  if (!diff.hunks.length) return null;
+
+  const out = [
+    '--- ' + diff.oldHeader,
+    '+++ ' + diff.newHeader
+  ];
+  for (const hunk of diff.hunks) {
+    out.push(
+      '@@ -' + hunk.oldStart + ',' + hunk.oldLines
+      + ' +' + hunk.newStart + ',' + hunk.newLines
+      + ' @@'
+    );
+    out.push(...hunk.lines.map(line =>
+      line.charAt(0) === "+"
+        ? stdoutColors.green(line)
+        : line.charAt(0) === "-"
+        ? stdoutColors.red(line)
+        : line
+    ));
+  }
+
+  return out.join('\n') + '\n';
+}

package/examples/basic/node_modules/toilscript/util/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig-base.json",
+  "compilerOptions": {
+    "esModuleInterop": true
+  },
+  "include": [
+    "./**/*.ts"
+  ]
+}

package/examples/basic/node_modules/toilscript/util/web.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Web polyfill definitions.
+ * @license Apache-2.0
+ */
+
+/** Fetches a file. */
+export function fetch(url: string): Promise<{
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  json(): Promise<any>;
+}>;

package/examples/basic/node_modules/toilscript/util/web.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Web polyfills.
+ * @license Apache-2.0
+ */
+
+import { fs } from "./node.js";
+
+var _fetch = typeof fetch === "function" ? fetch :
+  url => new Promise((resolve, reject) => {
+    fs.readFile(url, (err, data) => {
+      if (err) reject(err);
+      resolve({
+        arrayBuffer() {
+          let offset = data.byteOffset;
+          return Promise.resolve(data.buffer.slice(offset, offset + data.byteLength));
+        },
+        text() {
+          return Promise.resolve(data.toString());
+        },
+        json() {
+          try {
+            return Promise.resolve(JSON.parse(data.toString()));
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        }
+      });
+    });
+  });
+
+export {
+  _fetch as fetch
+};