@blamejs/blamejs-shop 0.2.24 → 0.2.25

package/lib/vendor/blamejs/lib/ai-dp.js

@@ -102,7 +102,7 @@ function _frGt(a, b)  { return a.num * b.den >  b.num * a.den; }       // a >  b
 // Uniform BigInt in [0, m) via rejection sampling on CSPRNG bytes —
 // no modulo bias.
 function _uniformBelow(m) {
-  if (m <= 0n) throw new AiDpError("aiDp/internal", "ai.dp: _uniformBelow needs m > 0");
+  if (m <= 0n) throw new AiDpError("ai-dp/internal", "ai.dp: _uniformBelow needs m > 0");
   if (m === 1n) return 0n;
   var bits = m.toString(2).length;
   var bytes = Math.ceil(bits / 8);                        // allow:raw-byte-literal — bits-per-byte divisor, not a size
@@ -296,23 +296,23 @@ function mechanism(opts) {
   validateOpts(opts, ["type", "sensitivity", "epsilon", "delta", "bound"], "ai.dp.mechanism");
 
   if (MECHANISMS.indexOf(opts.type) === -1) {
-    throw new AiDpError("aiDp/bad-mechanism",
+    throw new AiDpError("ai-dp/bad-mechanism",
       "ai.dp.mechanism: type must be one of " + MECHANISMS.join(" / ") +
       " (exponential / sparse-vector are deferred — their float-safe constructions " +
       "re-open on demand)");
   }
   if (typeof opts.sensitivity !== "number" || !isFinite(opts.sensitivity) || opts.sensitivity <= 0) {
-    throw new AiDpError("aiDp/bad-sensitivity",
+    throw new AiDpError("ai-dp/bad-sensitivity",
       "ai.dp.mechanism: sensitivity must be a positive finite number");
   }
   if (typeof opts.epsilon !== "number" || !isFinite(opts.epsilon) || opts.epsilon <= 0) {
-    throw new AiDpError("aiDp/bad-epsilon",
+    throw new AiDpError("ai-dp/bad-epsilon",
       "ai.dp.mechanism: epsilon must be a positive finite number");
   }
 
   if (opts.type === "laplace") {
     if (typeof opts.bound !== "number" || !isFinite(opts.bound) || opts.bound <= 0) {
-      throw new AiDpError("aiDp/bad-bound",
+      throw new AiDpError("ai-dp/bad-bound",
         "ai.dp.mechanism: laplace requires bound > 0 (the snapping clamp; the " +
         "privacy guarantee depends on it)");
     }
@@ -325,11 +325,11 @@ function mechanism(opts) {
 
   // gaussian
   if (typeof opts.delta !== "number" || !isFinite(opts.delta) || opts.delta <= 0 || opts.delta >= 1) {
-    throw new AiDpError("aiDp/bad-delta",
+    throw new AiDpError("ai-dp/bad-delta",
       "ai.dp.mechanism: gaussian requires 0 < delta < 1");
   }
   if (opts.epsilon > 1) {
-    throw new AiDpError("aiDp/epsilon-too-large",
+    throw new AiDpError("ai-dp/epsilon-too-large",
       "ai.dp.mechanism: the classic Gaussian calibration is proven for epsilon <= 1; " +
       "split into multiple releases under an rdp budget, or the analytic Gaussian " +
       "mechanism (Balle-Wang 2018) re-opens this path on demand");
@@ -346,7 +346,7 @@ function mechanism(opts) {
 // budget wraps this).
 function _applyMechanism(m, value) {
   if (typeof value !== "number" || !isFinite(value)) {
-    throw new AiDpError("aiDp/bad-value", "ai.dp: value must be a finite number");
+    throw new AiDpError("ai-dp/bad-value", "ai.dp: value must be a finite number");
   }
   if (m.type === "laplace") {
     return _snappingLaplace(value, m.scale, m.bound);
@@ -403,22 +403,22 @@ function budget(opts) {
   validateOpts(opts, ["scope", "epsilon", "delta", "accounting", "audit"], "ai.dp.budget");
 
   validateOpts.requireNonEmptyString(opts.scope,
-    "ai.dp.budget: scope", AiDpError, "aiDp/bad-scope");
+    "ai.dp.budget: scope", AiDpError, "ai-dp/bad-scope");
   if (typeof opts.epsilon !== "number" || !isFinite(opts.epsilon) || opts.epsilon <= 0) {
-    throw new AiDpError("aiDp/bad-epsilon", "ai.dp.budget: epsilon must be a positive finite number");
+    throw new AiDpError("ai-dp/bad-epsilon", "ai.dp.budget: epsilon must be a positive finite number");
   }
   var totalEpsilon = opts.epsilon;
   var totalDelta = (opts.delta == null) ? 0 : opts.delta;
   if (typeof totalDelta !== "number" || !isFinite(totalDelta) || totalDelta < 0 || totalDelta >= 1) {
-    throw new AiDpError("aiDp/bad-delta", "ai.dp.budget: delta must be in [0, 1)");
+    throw new AiDpError("ai-dp/bad-delta", "ai.dp.budget: delta must be in [0, 1)");
   }
   var accounting = (opts.accounting == null) ? "basic" : opts.accounting;
   if (ACCOUNTINGS.indexOf(accounting) === -1) {
-    throw new AiDpError("aiDp/bad-accounting",
+    throw new AiDpError("ai-dp/bad-accounting",
       "ai.dp.budget: accounting must be one of " + ACCOUNTINGS.join(" / "));
   }
   if (accounting === "rdp" && totalDelta <= 0) {
-    throw new AiDpError("aiDp/bad-accounting",
+    throw new AiDpError("ai-dp/bad-accounting",
       "ai.dp.budget: rdp accounting requires delta > 0 (the RDP→(ε,δ) conversion is " +
       "undefined at delta = 0; use basic accounting for pure-ε budgets)");
   }
@@ -457,11 +457,11 @@ function budget(opts) {
 
   function consume(m, value) {
     if (!m || typeof m !== "object" || MECHANISMS.indexOf(m.type) === -1) {
-      throw new AiDpError("aiDp/bad-mechanism",
+      throw new AiDpError("ai-dp/bad-mechanism",
         "ai.dp.budget.consume: first argument must be a b.ai.dp.mechanism");
     }
     if (m.type === "gaussian" && totalDelta <= 0) {
-      throw new AiDpError("aiDp/bad-delta",
+      throw new AiDpError("ai-dp/bad-delta",
         "ai.dp.budget.consume: a gaussian mechanism needs a scope delta > 0");
     }
 
@@ -475,7 +475,7 @@ function budget(opts) {
           requestEpsilon: m.epsilon, requestDelta: m.delta,
           spentEpsilon: spentEpsilon, totalEpsilon: totalEpsilon,
         });
-        throw new AiDpError("aiDp/budget-exhausted",
+        throw new AiDpError("ai-dp/budget-exhausted",
           "ai.dp.budget.consume: scope '" + scope + "' would spend ε=" +
           (spentEpsilon + m.epsilon) + "/" + totalEpsilon + ", δ=" +
           (spentDelta + m.delta) + "/" + totalDelta + "; refused");
@@ -489,7 +489,7 @@ function budget(opts) {
           scope: scope, accounting: accounting, mechanism: m.type,
           projectedEpsilon: trialEps, totalEpsilon: totalEpsilon,
         });
-        throw new AiDpError("aiDp/budget-exhausted",
+        throw new AiDpError("ai-dp/budget-exhausted",
           "ai.dp.budget.consume: scope '" + scope + "' would reach ε=" +
           trialEps.toFixed(4) + " of " + totalEpsilon + " at δ=" + totalDelta + "; refused");
       }

package/lib/vendor/blamejs/lib/ai-input.js

@@ -104,12 +104,12 @@ function classify(input, opts) {
   var auditOn = opts.audit !== false;
 
   if (typeof input !== "string") {
-    throw errorClass.factory("BAD_INPUT",
+    throw errorClass.factory("ai-input/bad-input",
       "aiInput.classify: input must be a string");
   }
   var byteLen = Buffer.byteLength(input, "utf8");
   if (byteLen > maxBytes) {
-    throw errorClass.factory("INPUT_TOO_LARGE",
+    throw errorClass.factory("ai-input/input-too-large",
       "aiInput.classify: input exceeds " + maxBytes + " bytes (got " + byteLen + ")");
   }
 
@@ -187,7 +187,7 @@ function refuseIfMalicious(input, opts) {
   var errorClass = opts.errorClass || AiInputError;
   var result = classify(input, opts);
   if (result.verdict === "malicious") {
-    throw errorClass.factory("MALICIOUS_INPUT",
+    throw errorClass.factory("ai-input/malicious-input",
       "aiInput: input flagged as malicious (signals: " +
       result.signals.map(function (s) { return s.id; }).join(", ") + ")");
   }

package/lib/vendor/blamejs/lib/ai-pref.js

@@ -38,25 +38,25 @@ var SNIPPET_VALUES = ["allow", "deny"];
 
 function _validate(opts) {
   if (!opts || typeof opts !== "object") {
-    throw AiPrefError.factory("BAD_OPTS",
+    throw AiPrefError.factory("ai-pref/bad-opts",
       "aiPref: opts required");
   }
   var train   = opts.train   || "deny";
   var infer   = opts.infer   || "allow";
   var snippet = opts.snippet || "allow";
   if (TRAIN_VALUES.indexOf(train) === -1) {
-    throw AiPrefError.factory("BAD_TRAIN", "aiPref: train must be one of " + TRAIN_VALUES.join(", "));
+    throw AiPrefError.factory("ai-pref/bad-train", "aiPref: train must be one of " + TRAIN_VALUES.join(", "));
   }
   if (INFER_VALUES.indexOf(infer) === -1) {
-    throw AiPrefError.factory("BAD_INFER", "aiPref: infer must be one of " + INFER_VALUES.join(", "));
+    throw AiPrefError.factory("ai-pref/bad-infer", "aiPref: infer must be one of " + INFER_VALUES.join(", "));
   }
   if (SNIPPET_VALUES.indexOf(snippet) === -1) {
-    throw AiPrefError.factory("BAD_SNIPPET", "aiPref: snippet must be one of " + SNIPPET_VALUES.join(", "));
+    throw AiPrefError.factory("ai-pref/bad-snippet", "aiPref: snippet must be one of " + SNIPPET_VALUES.join(", "));
   }
   if ((train === "paid" || infer === "paid") &&
       (!opts.price || typeof opts.price.amountUsd !== "number" ||
        !isFinite(opts.price.amountUsd) || opts.price.amountUsd <= 0)) {
-    throw AiPrefError.factory("BAD_PRICE",
+    throw AiPrefError.factory("ai-pref/bad-price",
       "aiPref: price.amountUsd (positive finite number) required when train or infer is 'paid'");
   }
   return { train: train, infer: infer, snippet: snippet, price: opts.price || null };
@@ -140,10 +140,10 @@ function serializeHeader(opts) {
  */
 function parseHeader(value) {
   if (typeof value !== "string" || value.length === 0) {
-    throw AiPrefError.factory("BAD_HEADER", "aiPref.parseHeader: value required");
+    throw AiPrefError.factory("ai-pref/bad-header", "aiPref.parseHeader: value required");
   }
   if (value.length > 1024) {                                                                   // allow:raw-byte-literal — header value cap, not bytes
-    throw AiPrefError.factory("HEADER_TOO_LARGE",
+    throw AiPrefError.factory("ai-pref/header-too-large",
       "aiPref.parseHeader: value exceeds 1024 chars");
   }
   structuredFields.refuseControlBytes(value, {
@@ -206,7 +206,7 @@ function robotsBlock(opts) {
   var v = _validate(opts);
   var ua = opts.userAgent || "*";
   if (typeof ua !== "string" || ua.length === 0 || ua.length > 256) {                          // allow:raw-byte-literal — UA-string cap, not bytes
-    throw AiPrefError.factory("BAD_USER_AGENT",
+    throw AiPrefError.factory("ai-pref/bad-user-agent",
       "aiPref.robotsBlock: userAgent must be 1-256 char string (or omit for *)");
   }
   return "User-agent: " + ua + "\n" +
@@ -298,7 +298,7 @@ function middleware(opts) {
  */
 function refusePaidCrawl(req, res, opts) {
   if (!opts || !opts.price || typeof opts.price.amountUsd !== "number") {
-    throw AiPrefError.factory("BAD_PRICE",
+    throw AiPrefError.factory("ai-pref/bad-price",
       "aiPref.refusePaidCrawl: opts.price.amountUsd required");
   }
   var body = JSON.stringify({

package/lib/vendor/blamejs/lib/ai-quota.js

@@ -257,20 +257,20 @@ function create(opts) {
 
   var dimension = opts.dimension;
   if (DIMENSIONS.indexOf(dimension) === -1) {
-    throw new AiQuotaError("aiQuota/bad-dimension",
+    throw new AiQuotaError("ai-quota/bad-dimension",
       "ai.quota.create: dimension must be one of " + DIMENSIONS.join(" / ") +
       " (got " + JSON.stringify(dimension) + ")");
   }
 
   var period = opts.period;
   if (PERIODS.indexOf(period) === -1) {
-    throw new AiQuotaError("aiQuota/bad-period",
+    throw new AiQuotaError("ai-quota/bad-period",
       "ai.quota.create: period must be one of " + PERIODS.join(" / ") +
       " (got " + JSON.stringify(period) + ")");
   }
 
   if (typeof opts.limit !== "number" || !isFinite(opts.limit) || opts.limit <= 0) {
-    throw new AiQuotaError("aiQuota/bad-limit",
+    throw new AiQuotaError("ai-quota/bad-limit",
       "ai.quota.create: limit must be a positive finite number");
   }
   var defaultLimit = opts.limit;
@@ -281,7 +281,7 @@ function create(opts) {
 
   var enforcement = (opts.enforcement == null) ? "hard" : opts.enforcement;
   if (ENFORCEMENTS.indexOf(enforcement) === -1) {
-    throw new AiQuotaError("aiQuota/bad-enforcement",
+    throw new AiQuotaError("ai-quota/bad-enforcement",
       "ai.quota.create: enforcement must be one of " + ENFORCEMENTS.join(" / ") +
       " (got " + JSON.stringify(enforcement) + ")");
   }
@@ -353,11 +353,11 @@ function create(opts) {
 
   function consume(tenantId, model, amount, consumeOpts) {
     validateOpts.requireNonEmptyString(tenantId,
-      "ai.quota.consume: tenantId", AiQuotaError, "aiQuota/bad-tenant");
+      "ai.quota.consume: tenantId", AiQuotaError, "ai-quota/bad-tenant");
     validateOpts.requireNonEmptyString(model,
-      "ai.quota.consume: model", AiQuotaError, "aiQuota/bad-model");
+      "ai.quota.consume: model", AiQuotaError, "ai-quota/bad-model");
     if (typeof amount !== "number" || !isFinite(amount) || amount < 0) {
-      throw new AiQuotaError("aiQuota/bad-amount",
+      throw new AiQuotaError("ai-quota/bad-amount",
         "ai.quota.consume: amount must be a non-negative finite number");
     }
     consumeOpts = consumeOpts || {};
@@ -366,7 +366,7 @@ function create(opts) {
     // enforcer; still validated against the allowlist.
     var mode = (consumeOpts.enforcement == null) ? enforcement : consumeOpts.enforcement;
     if (ENFORCEMENTS.indexOf(mode) === -1) {
-      throw new AiQuotaError("aiQuota/bad-enforcement",
+      throw new AiQuotaError("ai-quota/bad-enforcement",
         "ai.quota.consume: enforcement override must be one of " + ENFORCEMENTS.join(" / "));
     }
 
@@ -401,7 +401,7 @@ function create(opts) {
         enforcement: mode, nodeId: _nodeId(),
       });
       _emitMetric("ai.quota.exceeded", 1);
-      throw new AiQuotaError("aiQuota/exceeded",
+      throw new AiQuotaError("ai-quota/exceeded",
         "ai.quota.consume: tenant '" + tenantId + "' model '" + model +
         "' is at " + rv.used + " of " + limit + " " + dimension +
         " this " + period + "; consuming " + amount + " would exceed the budget — call refused");
@@ -432,9 +432,9 @@ function create(opts) {
 
   function check(tenantId, model) {
     validateOpts.requireNonEmptyString(tenantId,
-      "ai.quota.check: tenantId", AiQuotaError, "aiQuota/bad-tenant");
+      "ai.quota.check: tenantId", AiQuotaError, "ai-quota/bad-tenant");
     validateOpts.requireNonEmptyString(model,
-      "ai.quota.check: model", AiQuotaError, "aiQuota/bad-model");
+      "ai.quota.check: model", AiQuotaError, "ai-quota/bad-model");
     var now = Date.now();
     var windowStart = _windowStartFor(period, now);
     var resetsAt = _resetsAtFor(period, windowStart);
@@ -454,10 +454,10 @@ function create(opts) {
       return;
     }
     validateOpts.requireNonEmptyString(tenantId,
-      "ai.quota.reset: tenantId", AiQuotaError, "aiQuota/bad-tenant");
+      "ai.quota.reset: tenantId", AiQuotaError, "ai-quota/bad-tenant");
     if (model !== undefined) {
       validateOpts.requireNonEmptyString(model,
-        "ai.quota.reset: model", AiQuotaError, "aiQuota/bad-model");
+        "ai.quota.reset: model", AiQuotaError, "ai-quota/bad-model");
       store.reset(_keyFor(tenantId, model, windowStart));
       return;
     }
@@ -470,7 +470,7 @@ function create(opts) {
       for (var i = 0; i < keys.length; i++) store.reset(keys[i]);
       return;
     }
-    throw new AiQuotaError("aiQuota/reset-unsupported",
+    throw new AiQuotaError("ai-quota/reset-unsupported",
       "ai.quota.reset: tenant-wide reset with an external store requires " +
       "an explicit model argument (per-key) or a store-side prefix delete");
   }
@@ -491,14 +491,14 @@ function create(opts) {
 function _validateLimitMap(map, label) {
   if (map == null) return {};
   if (typeof map !== "object" || Array.isArray(map)) {
-    throw new AiQuotaError("aiQuota/bad-override",
+    throw new AiQuotaError("ai-quota/bad-override",
       "ai.quota.create: " + label + " must be a plain object { key: limit }");
   }
   var keys = Object.keys(map);
   for (var i = 0; i < keys.length; i++) {
     var v = map[keys[i]];
     if (typeof v !== "number" || !isFinite(v) || v <= 0) {
-      throw new AiQuotaError("aiQuota/bad-override",
+      throw new AiQuotaError("ai-quota/bad-override",
         "ai.quota.create: " + label + "['" + keys[i] +
         "'] must be a positive finite number");
     }
@@ -512,7 +512,7 @@ function _validateStore(store) {
       typeof store.add !== "function" ||
       typeof store.get !== "function" ||
       typeof store.reset !== "function") {
-    throw new AiQuotaError("aiQuota/bad-store",
+    throw new AiQuotaError("ai-quota/bad-store",
       "ai.quota.create: store must expose reserve / add / get / reset functions");
   }
 }

package/lib/vendor/blamejs/lib/arg-parser.js

@@ -53,17 +53,17 @@ function _isPlainNonEmpty(s) {
 
 function _validateFlagName(name) {
   if (!_isPlainNonEmpty(name)) {
-    throw new ArgParserError("argParser/flag-name-invalid",
+    throw new ArgParserError("arg-parser/flag-name-invalid",
       "flag name must be a non-empty string");
   }
   if (FORBIDDEN_NAMES.indexOf(name) !== -1) {
-    throw new ArgParserError("argParser/flag-name-forbidden",
+    throw new ArgParserError("arg-parser/flag-name-forbidden",
       "flag name '" + name + "' is reserved");
   }
   // ASCII-only kebab-/snake-case identifier. Keeps every flag name safe
   // to embed in help text and prevents `--foo$bar=baz` style oddities.
   if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
-    throw new ArgParserError("argParser/flag-name-shape",
+    throw new ArgParserError("arg-parser/flag-name-shape",
       "flag name '" + name + "' must match [a-zA-Z][a-zA-Z0-9_-]*");
   }
 }
@@ -71,26 +71,26 @@ function _validateFlagName(name) {
 function _validateAlias(alias, ownerName) {
   if (alias === undefined || alias === null) return;
   if (typeof alias !== "string" || alias.length !== 1 || !/^[a-zA-Z]$/.test(alias)) {
-    throw new ArgParserError("argParser/alias-shape",
+    throw new ArgParserError("arg-parser/alias-shape",
       "flag '" + ownerName + "' alias must be a single letter [a-zA-Z]");
   }
 }
 
 function _validateFlagSpec(spec, ownerLabel) {
   if (!spec || typeof spec !== "object") {
-    throw new ArgParserError("argParser/flag-spec-invalid",
+    throw new ArgParserError("arg-parser/flag-spec-invalid",
       ownerLabel + ": flag spec must be an object");
   }
   _validateFlagName(spec.name);
   _validateAlias(spec.alias, spec.name);
   var type = spec.type || "string";
   if (SUPPORTED_TYPES.indexOf(type) === -1) {
-    throw new ArgParserError("argParser/flag-type-unsupported",
+    throw new ArgParserError("arg-parser/flag-type-unsupported",
       ownerLabel + ": flag '" + spec.name +
       "' type '" + type + "' must be one of " + SUPPORTED_TYPES.join(", "));
   }
   if (spec.description !== undefined && typeof spec.description !== "string") {
-    throw new ArgParserError("argParser/flag-description-invalid",
+    throw new ArgParserError("arg-parser/flag-description-invalid",
       ownerLabel + ": flag '" + spec.name + "' description must be a string");
   }
 }
@@ -101,7 +101,7 @@ function _coerceValue(spec, raw, label) {
   if (type === "number") {
     var n = Number(raw);
     if (!isFinite(n)) {
-      throw new ArgParserError("argParser/value-not-number",
+      throw new ArgParserError("arg-parser/value-not-number",
         label + " '" + spec.name + "' expected a number, got " + JSON.stringify(raw));
     }
     return n;
@@ -112,7 +112,7 @@ function _coerceValue(spec, raw, label) {
     var s = String(raw).toLowerCase();
     if (s === "true" || s === "1" || s === "yes")  return true;
     if (s === "false" || s === "0" || s === "no")  return false;
-    throw new ArgParserError("argParser/value-not-boolean",
+    throw new ArgParserError("arg-parser/value-not-boolean",
       label + " '" + spec.name + "' expected boolean, got " + JSON.stringify(raw));
   }
   if (type === "list") {
@@ -121,7 +121,7 @@ function _coerceValue(spec, raw, label) {
     return s2.indexOf(",") === -1 ? [s2] : s2.split(",");
   }
   // Unreachable: validated at create-time.
-  throw new ArgParserError("argParser/type-unreachable",
+  throw new ArgParserError("arg-parser/type-unreachable",
     "unsupported flag type '" + type + "'");
 }
 
@@ -132,13 +132,13 @@ function _buildFlagIndex(flagSpecs, ownerLabel) {
     var spec = flagSpecs[i];
     _validateFlagSpec(spec, ownerLabel);
     if (byName[spec.name]) {
-      throw new ArgParserError("argParser/flag-duplicate",
+      throw new ArgParserError("arg-parser/flag-duplicate",
         ownerLabel + ": flag '" + spec.name + "' declared twice");
     }
     byName[spec.name] = spec;
     if (spec.alias) {
       if (byAlias[spec.alias]) {
-        throw new ArgParserError("argParser/alias-duplicate",
+        throw new ArgParserError("arg-parser/alias-duplicate",
           ownerLabel + ": alias '-" + spec.alias + "' declared twice");
       }
       byAlias[spec.alias] = spec;
@@ -232,12 +232,12 @@ function _renderCommandHelp(parser, command) {
 // command-name (the first non-flag token, when commands are configured).
 function _splitArgv(parser, argv) {
   if (!Array.isArray(argv)) {
-    throw new ArgParserError("argParser/argv-not-array",
+    throw new ArgParserError("arg-parser/argv-not-array",
       "argv must be an array of strings");
   }
   for (var n = 0; n < argv.length; n++) {
     if (typeof argv[n] !== "string") {
-      throw new ArgParserError("argParser/argv-element-not-string",
+      throw new ArgParserError("arg-parser/argv-element-not-string",
         "argv[" + n + "] must be a string");
     }
   }
@@ -256,7 +256,7 @@ function _splitArgv(parser, argv) {
       if (!parser.commands.byName[name]) {
         // Surface help / version as built-ins even when no command matches.
         if (name === "help") return { command: "__help__", pre: argv.slice(0, i), rest: argv.slice(i + 1) };
-        throw new ArgParserError("argParser/unknown-command",
+        throw new ArgParserError("arg-parser/unknown-command",
           "unknown command '" + name + "'");
       }
       return { command: name, pre: argv.slice(0, i), rest: argv.slice(i + 1) };
@@ -299,7 +299,7 @@ function _consumeFlags(index, tokens) {
     if (tok.indexOf("--") === 0) {
       var rest = tok.slice(2);
       if (FORBIDDEN_NAMES.indexOf(rest.split("=")[0]) !== -1) {
-        throw new ArgParserError("argParser/argv-forbidden-name",
+        throw new ArgParserError("arg-parser/argv-forbidden-name",
           "flag '--" + rest.split("=")[0] + "' is reserved");
       }
       var eq = rest.indexOf("=");
@@ -313,7 +313,7 @@ function _consumeFlags(index, tokens) {
       }
       spec = index.byName[nm];
       if (!spec) {
-        throw new ArgParserError("argParser/unknown-flag",
+        throw new ArgParserError("arg-parser/unknown-flag",
           "unknown flag '--" + nm + "'");
       }
     } else if (tok.indexOf("-") === 0 && tok.length >= 2) {
@@ -329,12 +329,12 @@ function _consumeFlags(index, tokens) {
         ach = alias;
       }
       if (ach.length !== 1) {
-        throw new ArgParserError("argParser/short-flag-shape",
+        throw new ArgParserError("arg-parser/short-flag-shape",
           "short flag '" + tok + "' must be a single letter (use --long-form for multi-char names)");
       }
       spec = index.byAlias[ach];
       if (!spec) {
-        throw new ArgParserError("argParser/unknown-alias",
+        throw new ArgParserError("arg-parser/unknown-alias",
           "unknown short flag '-" + ach + "'");
       }
     } else {
@@ -349,7 +349,7 @@ function _consumeFlags(index, tokens) {
     } else {
       if (!hasInlineValue) {
         if (i + 1 >= tokens.length) {
-          throw new ArgParserError("argParser/value-missing",
+          throw new ArgParserError("arg-parser/value-missing",
             "flag '--" + spec.name + "' requires a value");
         }
         rawValue = tokens[++i];
@@ -377,7 +377,7 @@ function _applyDefaultsAndRequired(specs, flags, ownerLabel) {
   for (var k = 0; k < specs.length; k++) {
     var s = specs[k];
     if (s.required && flags[s.name] === undefined) {
-      throw new ArgParserError("argParser/missing-required",
+      throw new ArgParserError("arg-parser/missing-required",
         ownerLabel + ": flag '--" + s.name + "' is required");
     }
   }
@@ -385,23 +385,23 @@ function _applyDefaultsAndRequired(specs, flags, ownerLabel) {
 
 function _validateCommandSpec(cmd) {
   if (!cmd || typeof cmd !== "object") {
-    throw new ArgParserError("argParser/command-spec-invalid",
+    throw new ArgParserError("arg-parser/command-spec-invalid",
       "command spec must be an object");
   }
   if (!_isPlainNonEmpty(cmd.name)) {
-    throw new ArgParserError("argParser/command-name-invalid",
+    throw new ArgParserError("arg-parser/command-name-invalid",
       "command name must be a non-empty string");
   }
   if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(cmd.name)) {
-    throw new ArgParserError("argParser/command-name-shape",
+    throw new ArgParserError("arg-parser/command-name-shape",
       "command name '" + cmd.name + "' must match [a-zA-Z][a-zA-Z0-9_-]*");
   }
   if (cmd.handler !== undefined && typeof cmd.handler !== "function") {
-    throw new ArgParserError("argParser/command-handler-not-function",
+    throw new ArgParserError("arg-parser/command-handler-not-function",
       "command '" + cmd.name + "' handler must be a function");
   }
   if (cmd.description !== undefined && typeof cmd.description !== "string") {
-    throw new ArgParserError("argParser/command-description-invalid",
+    throw new ArgParserError("arg-parser/command-description-invalid",
       "command '" + cmd.name + "' description must be a string");
   }
 }
@@ -465,29 +465,29 @@ function _validateCommandSpec(cmd) {
  */
 function create(opts) {
   if (!opts || typeof opts !== "object") {
-    throw new ArgParserError("argParser/opts-required",
+    throw new ArgParserError("arg-parser/opts-required",
       "argParser.create requires an opts object");
   }
   var programName = opts.programName;
   if (programName !== undefined && typeof programName !== "string") {
-    throw new ArgParserError("argParser/program-name-invalid",
+    throw new ArgParserError("arg-parser/program-name-invalid",
       "programName must be a string");
   }
   var description = opts.description;
   if (description !== undefined && typeof description !== "string") {
-    throw new ArgParserError("argParser/description-invalid",
+    throw new ArgParserError("arg-parser/description-invalid",
       "description must be a string");
   }
   var topFlagsSpec = opts.flags || [];
   if (!Array.isArray(topFlagsSpec)) {
-    throw new ArgParserError("argParser/flags-not-array",
+    throw new ArgParserError("arg-parser/flags-not-array",
       "flags must be an array");
   }
   var topFlags = _buildFlagIndex(topFlagsSpec, "top-level");
 
   var commandsSpec = opts.commands || [];
   if (!Array.isArray(commandsSpec)) {
-    throw new ArgParserError("argParser/commands-not-array",
+    throw new ArgParserError("arg-parser/commands-not-array",
       "commands must be an array");
   }
   var commandsByName = Object.create(null);
@@ -496,12 +496,12 @@ function create(opts) {
     var c = commandsSpec[i];
     _validateCommandSpec(c);
     if (commandsByName[c.name]) {
-      throw new ArgParserError("argParser/command-duplicate",
+      throw new ArgParserError("arg-parser/command-duplicate",
         "command '" + c.name + "' declared twice");
     }
     var cmdFlagsSpec = c.flags || [];
     if (!Array.isArray(cmdFlagsSpec)) {
-      throw new ArgParserError("argParser/command-flags-not-array",
+      throw new ArgParserError("arg-parser/command-flags-not-array",
         "command '" + c.name + "' flags must be an array");
     }
     var cmdFlags = _buildFlagIndex(cmdFlagsSpec, "command '" + c.name + "'");
@@ -526,7 +526,7 @@ function create(opts) {
     if (commandName) {
       var cmd = commandsByName[commandName];
       if (!cmd) {
-        throw new ArgParserError("argParser/help-unknown-command",
+        throw new ArgParserError("arg-parser/help-unknown-command",
           "no command named '" + commandName + "'");
       }
       return _renderCommandHelp(parser, cmd);
@@ -645,7 +645,7 @@ function create(opts) {
  */
 function parseRaw(argv) {
   if (!Array.isArray(argv)) {
-    throw new ArgParserError("argParser/argv-not-array",
+    throw new ArgParserError("arg-parser/argv-not-array",
       "argv must be an array of strings");
   }
   var pos = [];
@@ -653,7 +653,7 @@ function parseRaw(argv) {
   for (var i = 0; i < argv.length; i++) {
     var tok = argv[i];
     if (typeof tok !== "string") {
-      throw new ArgParserError("argParser/argv-element-not-string",
+      throw new ArgParserError("arg-parser/argv-element-not-string",
         "argv[" + i + "] must be a string");
     }
     if (tok === "--") {
@@ -673,14 +673,14 @@ function parseRaw(argv) {
         val = true;
       }
       if (FORBIDDEN_NAMES.indexOf(name) !== -1) {
-        throw new ArgParserError("argParser/argv-forbidden-name",
+        throw new ArgParserError("arg-parser/argv-forbidden-name",
           "flag '--" + name + "' is reserved");
       }
       flags[name] = val;
     } else if (tok.indexOf("-") === 0 && tok.length === 2) {
       var s = tok.slice(1);
       if (FORBIDDEN_NAMES.indexOf(s) !== -1) {
-        throw new ArgParserError("argParser/argv-forbidden-name",
+        throw new ArgParserError("arg-parser/argv-forbidden-name",
           "flag '-" + s + "' is reserved");
       }
       flags[s] = true;

package/lib/vendor/blamejs/lib/audit-sign.js

@@ -178,13 +178,13 @@ var pendingNewKeyAlg = null;
 async function init(opts) {
   if (initialized) return;
   if (!opts || !opts.dataDir) {
-    throw new AuditSignError("auditSign/bad-init",
+    throw new AuditSignError("audit-sign/bad-init",
       "auditSign.init({ dataDir }) is required");
   }
 
   var mode = (opts.mode || "wrapped").toLowerCase();
   if (mode !== "wrapped" && mode !== "plaintext") {
-    throw new AuditSignError("auditSign/bad-mode",
+    throw new AuditSignError("audit-sign/bad-mode",
       "auditSign.init: mode must be 'wrapped' or 'plaintext'");
   }
   // Algorithm-on-generate. Validated against the supported list so
@@ -192,7 +192,7 @@ async function init(opts) {
   // deeper in nodeCrypto.
   var alg = (opts.algorithm || DEFAULT_SIGNING_ALG).toLowerCase();
   if (SUPPORTED_SIGNING_ALGS.indexOf(alg) === -1) {
-    throw new AuditSignError("auditSign/bad-algorithm",
+    throw new AuditSignError("audit-sign/bad-algorithm",
       "auditSign.init: algorithm must be one of " +
       SUPPORTED_SIGNING_ALGS.join(", ") + " (got: " + alg + ")");
   }
@@ -341,7 +341,7 @@ async function _initFirstRunWrapped() {
 
 function _requireInit() {
   if (!initialized) {
-    throw new AuditSignError("auditSign/not-initialized",
+    throw new AuditSignError("audit-sign/not-initialized",
       "auditSign.init() must be awaited before sign/verify");
   }
 }