stitchkit 0.115.0 → 0.117.0

package/dist/index-qezhmp51.js

@@ -0,0 +1,242 @@
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
+
+// src/primitives/decimal.ts
+import { z } from "zod";
+var DECIMAL_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function parseDecimal(value) {
+  if (!DECIMAL_PATTERN.test(value))
+    throw new TypeError(`invalid decimal value "${value}"`);
+  const negative = value.startsWith("-");
+  const unsigned = negative ? value.slice(1) : value;
+  const [whole = "0", fraction = ""] = unsigned.split(".");
+  const coefficient = BigInt(`${negative ? "-" : ""}${whole}${fraction}`);
+  return normalizeDecimal({ coefficient, scale: fraction.length });
+}
+function normalizeDecimal(parts) {
+  let coefficient = parts.coefficient;
+  let scale = parts.scale;
+  while (scale > 0 && coefficient % 10n === 0n) {
+    coefficient /= 10n;
+    scale -= 1;
+  }
+  return { coefficient, scale };
+}
+function formatDecimal(parts) {
+  const normalized = normalizeDecimal(parts);
+  const negative = normalized.coefficient < 0n;
+  const digits = (negative ? -normalized.coefficient : normalized.coefficient).toString();
+  if (normalized.scale === 0)
+    return `${negative ? "-" : ""}${digits}`;
+  const padded = digits.padStart(normalized.scale + 1, "0");
+  const point = padded.length - normalized.scale;
+  return `${negative ? "-" : ""}${padded.slice(0, point)}.${padded.slice(point)}`;
+}
+function addDecimal(left, right) {
+  const scale = Math.max(left.scale, right.scale);
+  const leftCoefficient = left.coefficient * 10n ** BigInt(scale - left.scale);
+  const rightCoefficient = right.coefficient * 10n ** BigInt(scale - right.scale);
+  return normalizeDecimal({ coefficient: leftCoefficient + rightCoefficient, scale });
+}
+function multiplyDecimalRatio(value, numerator, denominator) {
+  if (denominator <= 0n)
+    throw new RangeError("conversion denominator must be positive");
+  let coefficient = value.coefficient * numerator;
+  let scale = value.scale;
+  for (let extraScale = 0;extraScale <= 18; extraScale += 1) {
+    if (coefficient % denominator === 0n) {
+      return normalizeDecimal({ coefficient: coefficient / denominator, scale });
+    }
+    coefficient *= 10n;
+    scale += 1;
+  }
+  throw new RangeError("conversion does not have a finite decimal representation");
+}
+var DecimalStringSchema2 = z.string().refine((value) => {
+  try {
+    return formatDecimal(parseDecimal(value)) === value;
+  } catch {
+    return false;
+  }
+}, "expected a canonical decimal string");
+var DecimalInputSchema2 = z.string().regex(DECIMAL_PATTERN, "expected a decimal string").transform((value) => formatDecimal(parseDecimal(value)));
+
+// src/primitives/rounding.ts
+import { z as z2 } from "zod";
+var RoundingModeSchema2 = z2.enum(["half-up", "half-even", "up", "down"]);
+function isPositive(value) {
+  return DecimalStringSchema2.safeParse(value).success && parseDecimal(value).coefficient > 0n;
+}
+function compareParts(left, right) {
+  const scale = BigInt(Math.max(left.scale, right.scale));
+  const a = left.coefficient * 10n ** (scale - BigInt(left.scale));
+  const b = right.coefficient * 10n ** (scale - BigInt(right.scale));
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var RoundingTierSchema = z2.object({
+  below: z2.string().refine(isPositive, "expected a positive decimal").optional(),
+  step: z2.string().refine(isPositive, "expected a positive decimal")
+});
+var RoundingPolicySchema2 = z2.object({ mode: RoundingModeSchema2, tiers: z2.array(RoundingTierSchema).min(1) }).superRefine(({ tiers }, context) => {
+  const bounds = tiers.map((tier) => tier.below);
+  if (bounds.at(-1) !== undefined || bounds.slice(0, -1).includes(undefined)) {
+    context.addIssue({ code: "custom", message: 'only the last tier omits "below"' });
+  }
+  const ordered = bounds.flatMap((bound) => bound !== undefined && isPositive(bound) ? [parseDecimal(bound)] : []);
+  for (const [index, bound] of ordered.entries()) {
+    const next = ordered[index + 1];
+    if (next !== undefined && compareParts(bound, next) >= 0) {
+      context.addIssue({ code: "custom", message: '"below" must ascend' });
+    }
+  }
+});
+function defineRoundingPolicy2(policy) {
+  const { mode, tiers } = RoundingPolicySchema2.parse(policy);
+  return Object.freeze({ mode, tiers: tiers.map((tier) => Object.freeze(tier)) });
+}
+function absolute(value) {
+  return value < 0n ? -value : value;
+}
+function roundRatio(numerator, denominator, mode) {
+  const magnitude = absolute(numerator);
+  const quotient = magnitude / denominator;
+  const remainder = magnitude % denominator;
+  const twice = remainder * 2n;
+  const away = remainder !== 0n && (mode === "up" || mode === "half-up" && twice >= denominator || mode === "half-even" && (twice > denominator || twice === denominator && quotient % 2n === 1n));
+  const rounded = away ? quotient + 1n : quotient;
+  return numerator < 0n ? -rounded : rounded;
+}
+function stepFor(value, policy) {
+  const magnitude = { ...value, coefficient: absolute(value.coefficient) };
+  const tier = policy.tiers.find(({ below }) => below === undefined || compareParts(magnitude, parseDecimal(below)) < 0);
+  if (tier === undefined)
+    throw new TypeError("a rounding policy needs a last tier");
+  return parseDecimal(tier.step);
+}
+function hasWholeSteps(policy) {
+  return policy.tiers.every(({ step }) => parseDecimal(step).scale === 0);
+}
+function roundParts(value, policy) {
+  const step = stepFor(value, policy);
+  const steps = roundRatio(value.coefficient * 10n ** BigInt(step.scale), step.coefficient * 10n ** BigInt(value.scale), policy.mode);
+  return { coefficient: steps * step.coefficient, scale: step.scale };
+}
+function multiplyAndRound(left, right, policy) {
+  return roundParts({ coefficient: left.coefficient * right.coefficient, scale: left.scale + right.scale }, policy);
+}
+function roundDecimal2(value, policy) {
+  return formatDecimal(roundParts(parseDecimal(DecimalInputSchema2.parse(value)), policy));
+}
+
+// src/primitives/money.ts
+import { z as z3 } from "zod";
+var IntegerStringSchema = z3.string().regex(/^-?(?:0|[1-9]\d*)$/);
+function createMoneySchema2(currency) {
+  return z3.object({
+    minor: IntegerStringSchema,
+    currency: z3.literal(currency)
+  });
+}
+function parseMinor(value) {
+  return BigInt(IntegerStringSchema.parse(value.minor));
+}
+function assertSameCurrency(left, right) {
+  if (left.currency !== right.currency) {
+    throw new TypeError(`cannot combine "${left.currency}" and "${right.currency}"`);
+  }
+}
+function money(minor, currency) {
+  return Object.freeze({ minor: minor.toString(), currency });
+}
+function addMoney2(left, right) {
+  assertSameCurrency(left, right);
+  return money(parseMinor(left) + parseMinor(right), left.currency);
+}
+function subtractMoney2(left, right) {
+  assertSameCurrency(left, right);
+  return money(parseMinor(left) - parseMinor(right), left.currency);
+}
+function multiplyMoney2(value, quantity) {
+  if (typeof quantity === "number" && !Number.isSafeInteger(quantity)) {
+    throw new RangeError("quantity must be a safe integer");
+  }
+  const multiplier = typeof quantity === "bigint" ? quantity : BigInt(quantity);
+  return money(parseMinor(value) * multiplier, value.currency);
+}
+var ScaleSchema = z3.number().int().min(0).max(18);
+function moneyFromDecimal2(currency, value, scale) {
+  const places = ScaleSchema.parse(scale);
+  const parts = parseDecimal(DecimalInputSchema2.parse(value));
+  if (parts.scale > places) {
+    throw new RangeError(`"${value}" is finer than ${places} decimal places`);
+  }
+  return money(parts.coefficient * 10n ** BigInt(places - parts.scale), currency);
+}
+function moneyToDecimal2(value, scale) {
+  const places = ScaleSchema.parse(scale);
+  const minor = parseMinor(value);
+  const whole = formatDecimal({ coefficient: minor, scale: places });
+  if (places === 0)
+    return whole;
+  const [integer = "0", fraction = ""] = whole.split(".");
+  return `${integer}.${fraction.padEnd(places, "0")}`;
+}
+function assertMinorSteps(policy) {
+  if (!hasWholeSteps(policy)) {
+    throw new RangeError("a money rounding step must be a whole number of minor units");
+  }
+}
+function roundMoney2(value, policy) {
+  assertMinorSteps(policy);
+  const rounded = roundParts({ coefficient: parseMinor(value), scale: 0 }, policy);
+  return money(rounded.coefficient, value.currency);
+}
+function multiplyMoneyByDecimal2(value, factor, policy) {
+  assertMinorSteps(policy);
+  const rounded = multiplyAndRound({ coefficient: parseMinor(value), scale: 0 }, parseDecimal(DecimalInputSchema2.parse(factor)), policy);
+  return money(rounded.coefficient, value.currency);
+}
+function shareMoney2(value, numerator, denominator) {
+  if (denominator <= 0n)
+    throw new RangeError("denominator must be positive");
+  if (numerator < 0n)
+    throw new RangeError("numerator must be non-negative");
+  const scaled = parseMinor(value) * numerator;
+  return Object.freeze({
+    amount: money(scaled / denominator, value.currency),
+    remainder: Object.freeze({
+      numerator: (scaled % denominator).toString(),
+      denominator: denominator.toString(),
+      currency: value.currency
+    })
+  });
+}
+function splitMoney2(value, count) {
+  assertPositiveSafeInteger("count", count, RangeError);
+  const divisor = BigInt(count);
+  const total = parseMinor(value);
+  return Object.freeze({
+    part: money(total / divisor, value.currency),
+    count,
+    remainder: money(total % divisor, value.currency)
+  });
+}
+function defineMoney2(currency) {
+  const schema = createMoneySchema2(currency);
+  return Object.freeze({
+    currency,
+    schema,
+    create(minor) {
+      const parsed = schema.parse({ minor: minor.toString(), currency });
+      return Object.freeze(parsed);
+    },
+    add: addMoney2,
+    subtract: subtractMoney2,
+    multiply: multiplyMoney2,
+    share: shareMoney2,
+    split: splitMoney2
+  });
+}
+
+export { parseDecimal, formatDecimal, addDecimal, multiplyDecimalRatio, DecimalStringSchema2, DecimalInputSchema2, RoundingModeSchema2, RoundingPolicySchema2, defineRoundingPolicy2, roundDecimal2, createMoneySchema2, addMoney2, subtractMoney2, multiplyMoney2, moneyFromDecimal2, moneyToDecimal2, roundMoney2, multiplyMoneyByDecimal2, shareMoney2, splitMoney2, defineMoney2 };

package/dist/index-vv1sch8a.js

@@ -0,0 +1,94 @@
+// src/tracking/beacon.ts
+function sendUnloadBeacon2(url, body, sender = typeof navigator === "undefined" ? undefined : navigator) {
+  if (!sender || typeof sender.sendBeacon !== "function")
+    return false;
+  return sender.sendBeacon(url, body);
+}
+
+// src/tracking/privacy.ts
+var MASK = "[masked]";
+var MAX_REDACTED_CHARS = 16384;
+var TELEGRAM_SIGNED_FIELD = "tgwebappdata";
+var PASSWORD_FIELD = /^(?:current|new|old|confirm|repeat|repeated)?(?:password|passwd|pwd)(?:confirmation)?$/;
+var CREDENTIAL_FIELDS = new Set([
+  "token",
+  "accesstoken",
+  "idtoken",
+  "refreshtoken",
+  "authtoken",
+  "sessiontoken",
+  "csrftoken",
+  "resettoken",
+  "magictoken",
+  "secret",
+  "clientsecret",
+  "apikey",
+  "privatekey",
+  "authorization",
+  "signature",
+  "xamzsignature"
+]);
+var OAUTH_FIELDS = new Set(["code", "state", "sessionstate"]);
+var SIGNED_LOGIN_FIELDS = new Set(["hash"]);
+var PARAMETER = /([?&#])([^=&#?\s]+)=([^&#\s]*)/g;
+var URL_PASSWORD = /(https?:\/\/[^\s/:@]+:)[^\s/@]+(@)/gi;
+var BEARER = /\b(bearer\s+)[^\s,;]+/gi;
+var ASSIGNMENT = /(^|[^\w?&#/-])("[^"\n]+"|'[^'\n]+'|[\w.$[\]-]+)(\s*[:=]\s*)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;}]+)/g;
+function fieldName(key) {
+  const field = key.replace(/^amp;/, "").split(/[.[\]]/).filter((part) => part !== "" && !/^\d+$/.test(part)).at(-1) ?? "";
+  return field.replace(/[-_\s]/g, "").toLowerCase();
+}
+function isSecretField(key, context) {
+  const field = fieldName(key);
+  if (PASSWORD_FIELD.test(field) || CREDENTIAL_FIELDS.has(field))
+    return true;
+  if (field === TELEGRAM_SIGNED_FIELD)
+    return true;
+  if (context?.oauth && OAUTH_FIELDS.has(field))
+    return true;
+  return Boolean(context?.signedLogin && SIGNED_LOGIN_FIELDS.has(field));
+}
+function decodeKey(key) {
+  try {
+    return decodeURIComponent(key.replace(/\+/g, " "));
+  } catch {
+    return key;
+  }
+}
+function secretContextOf(input) {
+  const names = new Set(Array.from(input.matchAll(PARAMETER), (match) => fieldName(decodeKey(match[2] ?? ""))));
+  return {
+    oauth: names.has("state") && names.has("code"),
+    signedLogin: names.has("authdate")
+  };
+}
+function redactTrackingText2(input) {
+  const text = input.slice(0, MAX_REDACTED_CHARS);
+  const context = secretContextOf(text);
+  return text.replace(URL_PASSWORD, `$1${MASK}$2`).replace(BEARER, `$1${MASK}`).replace(PARAMETER, (whole, separator, key, value) => {
+    try {
+      if (isSecretField(decodeKey(key), context))
+        return `${separator}${key}=${MASK}`;
+      const decoded = decodeURIComponent(value.replace(/\+/g, " "));
+      const redacted = redactTrackingText2(decoded);
+      return redacted === decoded ? whole : `${separator}${key}=${encodeURIComponent(redacted)}`;
+    } catch {
+      return whole;
+    }
+  }).replace(ASSIGNMENT, (whole, prefix, key, assignment) => isSecretField(key.replace(/^["']|["']$/g, "")) ? `${prefix}${key}${assignment}${MASK}` : whole);
+}
+function redactTrackingValue2(value) {
+  if (typeof value === "string")
+    return redactTrackingText2(value);
+  if (Array.isArray(value))
+    return value.map(redactTrackingValue2);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+      key,
+      isSecretField(key) ? MASK : redactTrackingValue2(item)
+    ]));
+  }
+  return value;
+}
+
+export { sendUnloadBeacon2, redactTrackingText2, redactTrackingValue2 };

package/dist/{index-3qqdqwxe.js → index-w7jq3fz9.js}

@@ -25,12 +25,12 @@ import {
 } from "./index-htxh46ej.js";
 import {
   writeContainedFile
-} from "./index-j8kf56wx.js";
+} from "./index-q968hy6y.js";
 import {
   openPinnedDirectory,
   isSafeEntryName,
   containedEntryMetadata
-} from "./index-x0ddbj85.js";
+} from "./index-arjmb6de.js";
 import {
   collectToolSurface
 } from "./index-86nbfysb.js";
@@ -1348,6 +1348,8 @@ function groupKey(value) {
     return ABSENT;
   if (value === null)
     return "null";
+  if (value === "null" || value === ABSENT)
+    return JSON.stringify(value);
   if (typeof value === "object")
     return JSON.stringify(value);
   return String(value);
@@ -1355,7 +1357,20 @@ function groupKey(value) {
 function ordered(totals, top) {
   const entries = [...totals].sort(([leftKey, left], [rightKey, right]) => right === left ? leftKey.localeCompare(rightKey) : right - left);
   const sliced = top === undefined ? entries : entries.slice(0, top);
-  return Object.fromEntries(sliced);
+  return {
+    kind: "json",
+    data: Object.fromEntries(sliced),
+    order: sliced.map(([key]) => key)
+  };
+}
+function stringifyGroups(data, order, compact) {
+  if (!isRecord(data) || order.length === 0)
+    return JSON.stringify(data);
+  const lines = order.map((key) => `${JSON.stringify(key)}:${compact ? "" : " "}${JSON.stringify(data[key])}`);
+  return compact ? `{${lines.join(",")}}` : `{
+  ${lines.join(`,
+  `)}
+}`;
 }
 function numericValue(value, field) {
   if (isAbsent(value))
@@ -1440,7 +1455,7 @@ function renderCliView2(data, view) {
       const key = groupKey(readField(record, path));
       totals.set(key, (totals.get(key) ?? 0) + 1);
     }
-    return { kind: "json", data: ordered(totals, view.top) };
+    return ordered(totals, view.top);
   }
   const path = assertFieldPresent(records, view.field);
   if (view.by === undefined) {
@@ -1455,7 +1470,7 @@ function renderCliView2(data, view) {
     const key = groupKey(readField(record, byPath));
     totals.set(key, (totals.get(key) ?? 0) + (numericValue(readField(record, path), view.field) ?? 0));
   }
-  return { kind: "json", data: ordered(totals, view.top) };
+  return ordered(totals, view.top);
 }
 
 // src/tools/operations/wait-core.ts
@@ -2350,6 +2365,11 @@ async function emitManagedResult(session, command, initial, options) {
       stdout(viewed.text);
       return exit(downloadsOk ? 0 : 1);
     }
+    if (viewed.order) {
+      stdout(`${stringifyGroups(viewed.data, viewed.order, options.json === true)}
+`);
+      return exit(downloadsOk ? 0 : 1);
+    }
     result = { ...result, data: viewed.data };
   }
   const exitCode = emitResult2(result, { stdout, stderr }, emitOptionsFor(config, options.json, command));