npm - @happyvertical/smrt-core - Versions diffs - 0.40.19 → 0.40.21 - Mend

@happyvertical/smrt-core 0.40.19 → 0.40.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/manifest.json CHANGED Viewed

@@ -1,8 +1,8 @@
 {
   "version": "1.0.0",
-  "timestamp": 1784615517759,
+  "timestamp": 1785008640592,
   "packageName": "@happyvertical/smrt-core",
-  "packageVersion": "0.40.19",
+  "packageVersion": "0.40.21",
   "objects": {
     "@happyvertical/smrt-core:SmrtClass": {
       "name": "smrtclass",

package/dist/node_modules/.pnpm/brace-expansion@5.0.8/node_modules/brace-expansion/dist/esm/index.js ADDED Viewed

@@ -0,0 +1,174 @@
+import { balanced } from "../../../../../balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js";
+//#region ../../node_modules/.pnpm/brace-expansion@5.0.8/node_modules/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\\./g;
+var EXPANSION_MAX = 1e5;
+var EXPANSION_MAX_LENGTH = 4e6;
+function numeric(str) {
+	return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+	return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+	return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+/**
+* Basically just str.split(","), but handling cases
+* where we have nested braced sections, which should be
+* treated as individual members, like {a,{b,c},d}
+*/
+function parseCommaParts(str) {
+	if (!str) return [""];
+	const parts = [];
+	const m = balanced("{", "}", str);
+	if (!m) return str.split(",");
+	const { pre, body, post } = m;
+	const p = pre.split(",");
+	p[p.length - 1] += "{" + body + "}";
+	const postParts = parseCommaParts(post);
+	if (post.length) {
+		p[p.length - 1] += postParts.shift();
+		p.push.apply(p, postParts);
+	}
+	parts.push.apply(parts, p);
+	return parts;
+}
+function expand(str, options = {}) {
+	if (!str) return [];
+	const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH } = options;
+	if (str.slice(0, 2) === "{}") str = "\\{\\}" + str.slice(2);
+	return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
+}
+function embrace(str) {
+	return "{" + str + "}";
+}
+function isPadded(el) {
+	return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+	return i <= y;
+}
+function gte(i, y) {
+	return i >= y;
+}
+function combine(acc, pre, values, max, maxLength, dropEmpties) {
+	const out = [];
+	let length = 0;
+	for (let a = 0; a < acc.length; a++) for (let v = 0; v < values.length; v++) {
+		if (out.length >= max) return out;
+		const expansion = acc[a] + pre + values[v];
+		if (dropEmpties && !expansion) continue;
+		if (length + expansion.length > maxLength) return out;
+		out.push(expansion);
+		length += expansion.length;
+	}
+	return out;
+}
+function expandSequence(body, isAlphaSequence, max) {
+	const n = body.split(/\.\./);
+	const N = [];
+	/* c8 ignore start */
+	if (n[0] === void 0 || n[1] === void 0) return N;
+	/* c8 ignore stop */
+	const x = numeric(n[0]);
+	const y = numeric(n[1]);
+	const width = Math.max(n[0].length, n[1].length);
+	let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+	let test = lte;
+	if (y < x) {
+		incr *= -1;
+		test = gte;
+	}
+	const pad = n.some(isPadded);
+	for (let i = x; test(i, y) && N.length < max; i += incr) {
+		let c;
+		if (isAlphaSequence) {
+			c = String.fromCharCode(i);
+			if (c === "\\") c = "";
+		} else {
+			c = String(i);
+			if (pad) {
+				const need = width - c.length;
+				if (need > 0) {
+					const z = new Array(need + 1).join("0");
+					if (i < 0) c = "-" + z + c.slice(1);
+					else c = z + c;
+				}
+			}
+		}
+		N.push(c);
+	}
+	return N;
+}
+function expand_(str, max, maxLength, isTop) {
+	let acc = [""];
+	let dropEmpties = false;
+	let firstGroup = true;
+	for (;;) {
+		const m = balanced("{", "}", str);
+		if (!m) return combine(acc, str, [""], max, maxLength, dropEmpties);
+		const pre = m.pre;
+		if (/\$$/.test(pre)) {
+			acc = combine(acc, pre + "{" + m.body + "}", [""], max, maxLength, dropEmpties && !m.post.length);
+			firstGroup = false;
+			if (!m.post.length) break;
+			str = m.post;
+			continue;
+		}
+		const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+		const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+		const isSequence = isNumericSequence || isAlphaSequence;
+		const isOptions = m.body.indexOf(",") >= 0;
+		if (!isSequence && !isOptions) {
+			if (m.post.match(/,(?!,).*\}/)) {
+				str = m.pre + "{" + m.body + escClose + m.post;
+				isTop = true;
+				continue;
+			}
+			return combine(acc, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties);
+		}
+		if (firstGroup) {
+			dropEmpties = isTop && !isSequence;
+			firstGroup = false;
+		}
+		let values;
+		if (isSequence) values = expandSequence(m.body, isAlphaSequence, max);
+		else {
+			let n = parseCommaParts(m.body);
+			if (n.length === 1 && n[0] !== void 0) {
+				n = expand_(n[0], max, maxLength, false).map(embrace);
+				/* c8 ignore start */
+				if (n.length === 1) {
+					acc = combine(acc, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length);
+					if (!m.post.length) break;
+					str = m.post;
+					continue;
+				}
+			}
+			values = [];
+			for (let j = 0; j < n.length; j++) values.push.apply(values, expand_(n[j], max, maxLength, false));
+		}
+		acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
+		if (!m.post.length) break;
+		str = m.post;
+	}
+	return acc;
+}
+//#endregion
+export { EXPANSION_MAX, EXPANSION_MAX_LENGTH, expand };
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/brace-expansion@5.0.8/node_modules/brace-expansion/dist/esm/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/brace-expansion@5.0.8/node_modules/brace-expansion/dist/esm/index.js"],"sourcesContent":["import { balanced } from 'balanced-match';\nconst escSlash = '\\0SLASH' + Math.random() + '\\0';\nconst escOpen = '\\0OPEN' + Math.random() + '\\0';\nconst escClose = '\\0CLOSE' + Math.random() + '\\0';\nconst escComma = '\\0COMMA' + Math.random() + '\\0';\nconst escPeriod = '\\0PERIOD' + Math.random() + '\\0';\nconst escSlashPattern = new RegExp(escSlash, 'g');\nconst escOpenPattern = new RegExp(escOpen, 'g');\nconst escClosePattern = new RegExp(escClose, 'g');\nconst escCommaPattern = new RegExp(escComma, 'g');\nconst escPeriodPattern = new RegExp(escPeriod, 'g');\nconst slashPattern = /\\\\\\\\/g;\nconst openPattern = /\\\\{/g;\nconst closePattern = /\\\\}/g;\nconst commaPattern = /\\\\,/g;\nconst periodPattern = /\\\\\\./g;\nexport const EXPANSION_MAX = 100_000;\n// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An\n// input like `'{a,b}'.repeat(1500)` stays under that count - its output is\n// truncated to 100k results - while making every result ~1500 characters\n// long. The result set, and the intermediate arrays built while combining\n// brace sets, then grow large enough to exhaust memory and crash the process\n// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of\n// characters the accumulator may hold at any point, so memory stays flat no\n// matter how many brace groups are chained. The limit sits well above any\n// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M\n// characters) so legitimate input is unaffected.\nexport const EXPANSION_MAX_LENGTH = 4_000_000;\nfunction numeric(str) {\n return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);\n}\nfunction escapeBraces(str) {\n return str\n .replace(slashPattern, escSlash)\n .replace(openPattern, escOpen)\n .replace(closePattern, escClose)\n .replace(commaPattern, escComma)\n .replace(periodPattern, escPeriod);\n}\nfunction unescapeBraces(str) {\n return str\n .replace(escSlashPattern, '\\\\')\n .replace(escOpenPattern, '{')\n .replace(escClosePattern, '}')\n .replace(escCommaPattern, ',')\n .replace(escPeriodPattern, '.');\n}\n/**\n * Basically just str.split(\",\"), but handling cases\n * where we have nested braced sections, which should be\n * treated as individual members, like {a,{b,c},d}\n */\nfunction parseCommaParts(str) {\n if (!str) {\n return [''];\n }\n const parts = [];\n const m = balanced('{', '}', str);\n if (!m) {\n return str.split(',');\n }\n const { pre, body, post } = m;\n const p = pre.split(',');\n p[p.length - 1] += '{' + body + '}';\n const postParts = parseCommaParts(post);\n if (post.length) {\n ;\n p[p.length - 1] += postParts.shift();\n p.push.apply(p, postParts);\n }\n parts.push.apply(parts, p);\n return parts;\n}\nexport function expand(str, options = {}) {\n if (!str) {\n return [];\n }\n const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH } = options;\n // I don't know why Bash 4.3 does this, but it does.\n // Anything starting with {} will have the first two bytes preserved\n // but *only* at the top level, so {},a}b will not expand to anything,\n // but a{},b}c will be expanded to [a}c,abc].\n // One could argue that this is a bug in Bash, but since the goal of\n // this module is to match Bash's rules, we escape a leading {}\n if (str.slice(0, 2) === '{}') {\n str = '\\\\{\\\\}' + str.slice(2);\n }\n return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);\n}\nfunction embrace(str) {\n return '{' + str + '}';\n}\nfunction isPadded(el) {\n return /^-?0\\d/.test(el);\n}\nfunction lte(i, y) {\n return i <= y;\n}\nfunction gte(i, y) {\n return i >= y;\n}\n// Build `{ acc[a] + pre + values[v] }` for every combination, capping the\n// number of results at `max` and the total number of characters at `maxLength`.\n// This is the one place output grows, so bounding it here keeps the single\n// accumulator - and therefore memory - flat regardless of how many brace groups\n// are combined (CVE-2026-14257).\nfunction combine(acc, pre, values, max, maxLength, dropEmpties) {\n const out = [];\n let length = 0;\n for (let a = 0; a < acc.length; a++) {\n for (let v = 0; v < values.length; v++) {\n if (out.length >= max)\n return out;\n const expansion = acc[a] + pre + values[v];\n // Bash drops empty results at the top level. Skip them before they count\n // against `max`, so `max` bounds the number of *kept* results.\n if (dropEmpties && !expansion)\n continue;\n if (length + expansion.length > maxLength)\n return out;\n out.push(expansion);\n length += expansion.length;\n }\n }\n return out;\n}\n// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)\n// sequence body.\nfunction expandSequence(body, isAlphaSequence, max) {\n const n = body.split(/\\.\\./);\n const N = [];\n // A sequence body always splits into two or three parts, but the compiler\n // can't know that.\n /* c8 ignore start */\n if (n[0] === undefined || n[1] === undefined) {\n return N;\n }\n /* c8 ignore stop */\n const x = numeric(n[0]);\n const y = numeric(n[1]);\n const width = Math.max(n[0].length, n[1].length);\n let incr = n.length === 3 && n[2] !== undefined ?\n Math.max(Math.abs(numeric(n[2])), 1)\n : 1;\n let test = lte;\n const reverse = y < x;\n if (reverse) {\n incr *= -1;\n test = gte;\n }\n const pad = n.some(isPadded);\n for (let i = x; test(i, y) && N.length < max; i += incr) {\n let c;\n if (isAlphaSequence) {\n c = String.fromCharCode(i);\n if (c === '\\\\') {\n c = '';\n }\n }\n else {\n c = String(i);\n if (pad) {\n const need = width - c.length;\n if (need > 0) {\n const z = new Array(need + 1).join('0');\n if (i < 0) {\n c = '-' + z + c.slice(1);\n }\n else {\n c = z + c;\n }\n }\n }\n }\n N.push(c);\n }\n return N;\n}\nfunction expand_(str, max, maxLength, isTop) {\n // Consume the string's top-level brace groups left to right, threading a\n // running set of combined prefixes (`acc`). Expanding the tail iteratively -\n // rather than recursing on `m.post` once per group - keeps the native stack\n // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no\n // longer overflow the stack, and leaves a single accumulator whose size\n // `maxLength` bounds directly (CVE-2026-14257).\n let acc = [''];\n // Bash drops empty results, but only when the *first* top-level group is a\n // comma set - a sequence like `{a..\\}` may legitimately yield ''. The drop\n // is on the final strings, so it is applied to whichever `combine` produces\n // them (the one with no brace set left in the tail).\n let dropEmpties = false;\n let firstGroup = true;\n for (;;) {\n const m = balanced('{', '}', str);\n // No brace set left: the rest of the string is literal.\n if (!m) {\n return combine(acc, str, [''], max, maxLength, dropEmpties);\n }\n // no need to expand pre, since it is guaranteed to be free of brace-sets\n const pre = m.pre;\n if (/\\$$/.test(pre)) {\n acc = combine(acc, pre + '{' + m.body + '}', [''], max, maxLength, dropEmpties && !m.post.length);\n firstGroup = false;\n if (!m.post.length)\n break;\n str = m.post;\n continue;\n }\n const isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n const isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n const isSequence = isNumericSequence || isAlphaSequence;\n const isOptions = m.body.indexOf(',') >= 0;\n if (!isSequence && !isOptions) {\n // {a},b}\n if (m.post.match(/,(?!,).*\\}/)) {\n str = m.pre + '{' + m.body + escClose + m.post;\n isTop = true;\n continue;\n }\n // Nothing here expands, so the whole remaining string is literal.\n return combine(acc, pre + '{' + m.body + '}' + m.post, [''], max, maxLength, dropEmpties);\n }\n if (firstGroup) {\n dropEmpties = isTop && !isSequence;\n firstGroup = false;\n }\n let values;\n if (isSequence) {\n values = expandSequence(m.body, isAlphaSequence, max);\n }\n else {\n let n = parseCommaParts(m.body);\n if (n.length === 1 && n[0] !== undefined) {\n // x{{a,b}}y ==> x{a}y x{b}y\n n = expand_(n[0], max, maxLength, false).map(embrace);\n //XXX is this necessary? Can't seem to hit it in tests.\n /* c8 ignore start */\n if (n.length === 1) {\n acc = combine(acc, pre + n[0], [''], max, maxLength, dropEmpties && !m.post.length);\n if (!m.post.length)\n break;\n str = m.post;\n continue;\n }\n /* c8 ignore stop */\n }\n values = [];\n for (let j = 0; j < n.length; j++) {\n values.push.apply(values, expand_(n[j], max, maxLength, false));\n }\n }\n acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);\n if (!m.post.length)\n break;\n str = m.post;\n }\n return acc;\n}\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { expand } from "../../../../../brace-expansion@5.0.7/node_modules/brace-expansion/dist/esm/index.js";
+import { expand } from "../../../../../brace-expansion@5.0.8/node_modules/brace-expansion/dist/esm/index.js";
 import { assertValidPattern } from "./assert-valid-pattern.js";
 import { unescape } from "./unescape.js";
 import { AST } from "./ast.js";

package/dist/smrt-knowledge.json CHANGED Viewed

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-07-21T06:31:55.794Z",
+  "generatedAt": "2026-07-25T19:43:58.732Z",
   "packageName": "@happyvertical/smrt-core",
-  "packageVersion": "0.40.19",
+  "packageVersion": "0.40.21",
   "sourceManifestPath": "dist/manifest.json",
   "agentDocPath": "AGENTS.md",
   "sourceHashes": {
-    "manifest": "f5b2ceeb08e9fb464e4a9cf44bccdd725248b5b78d9eff24a5c36918d8d3cb85",
-    "packageJson": "fb8015a07d2093bc4a4e926b11b7e603d8f43bd9e321e1c694e703e9d0c65d19",
+    "manifest": "170943c0c866af9ac6ddf23d47d30a6b38d6b7cfd43d76901c5e6c88560c7953",
+    "packageJson": "365fa16fe8d56b2b1d537f3bc33ec103f3ec75f95eeddeaaee215cb58694c4de",
     "agents": "51e716c002ba5e152e5b8f63c8eae21edff8ffb99467b19cb12006c524d3921f"
   },
   "exports": [

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-core",
-  "version": "0.40.19",
+  "version": "0.40.21",
   "description": "Core AI agent framework with standardized collections, object-relational mapping, and code generators",
   "author": "HappyVertical",
   "type": "module",
@@ -164,9 +164,9 @@
     "tsx": "^4.23.0",
     "typescript": "5.9.3",
     "yaml": "^2.9.0",
-    "@happyvertical/smrt-config": "0.40.19",
-    "@happyvertical/smrt-scanner": "0.40.19",
-    "@happyvertical/smrt-types": "0.40.19"
+    "@happyvertical/smrt-config": "0.40.21",
+    "@happyvertical/smrt-types": "0.40.21",
+    "@happyvertical/smrt-scanner": "0.40.21"
   },
   "peerDependencies": {
     "@huggingface/transformers": ">=3.0.0 <4.0.0",

package/dist/node_modules/.pnpm/brace-expansion@5.0.7/node_modules/brace-expansion/dist/esm/index.js DELETED Viewed

@@ -1,150 +0,0 @@
-import { balanced } from "../../../../../balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js";
-//#region ../../node_modules/.pnpm/brace-expansion@5.0.7/node_modules/brace-expansion/dist/esm/index.js
-var escSlash = "\0SLASH" + Math.random() + "\0";
-var escOpen = "\0OPEN" + Math.random() + "\0";
-var escClose = "\0CLOSE" + Math.random() + "\0";
-var escComma = "\0COMMA" + Math.random() + "\0";
-var escPeriod = "\0PERIOD" + Math.random() + "\0";
-var escSlashPattern = new RegExp(escSlash, "g");
-var escOpenPattern = new RegExp(escOpen, "g");
-var escClosePattern = new RegExp(escClose, "g");
-var escCommaPattern = new RegExp(escComma, "g");
-var escPeriodPattern = new RegExp(escPeriod, "g");
-var slashPattern = /\\\\/g;
-var openPattern = /\\{/g;
-var closePattern = /\\}/g;
-var commaPattern = /\\,/g;
-var periodPattern = /\\\./g;
-var EXPANSION_MAX = 1e5;
-function numeric(str) {
-	return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-}
-function escapeBraces(str) {
-	return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-	return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-/**
-* Basically just str.split(","), but handling cases
-* where we have nested braced sections, which should be
-* treated as individual members, like {a,{b,c},d}
-*/
-function parseCommaParts(str) {
-	if (!str) return [""];
-	const parts = [];
-	const m = balanced("{", "}", str);
-	if (!m) return str.split(",");
-	const { pre, body, post } = m;
-	const p = pre.split(",");
-	p[p.length - 1] += "{" + body + "}";
-	const postParts = parseCommaParts(post);
-	if (post.length) {
-		p[p.length - 1] += postParts.shift();
-		p.push.apply(p, postParts);
-	}
-	parts.push.apply(parts, p);
-	return parts;
-}
-function expand(str, options = {}) {
-	if (!str) return [];
-	const { max = EXPANSION_MAX } = options;
-	if (str.slice(0, 2) === "{}") str = "\\{\\}" + str.slice(2);
-	return expand_(escapeBraces(str), max, true).map(unescapeBraces);
-}
-function embrace(str) {
-	return "{" + str + "}";
-}
-function isPadded(el) {
-	return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-	return i <= y;
-}
-function gte(i, y) {
-	return i >= y;
-}
-function expand_(str, max, isTop) {
-	/** @type {string[]} */
-	const expansions = [];
-	for (;;) {
-		const m = balanced("{", "}", str);
-		if (!m) return [str];
-		const pre = m.pre;
-		if (/\$$/.test(m.pre)) {
-			const post = m.post.length ? expand_(m.post, max, false) : [""];
-			for (let k = 0; k < post.length && k < max; k++) {
-				const expansion = pre + "{" + m.body + "}" + post[k];
-				expansions.push(expansion);
-			}
-			return expansions;
-		}
-		const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-		const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-		const isSequence = isNumericSequence || isAlphaSequence;
-		const isOptions = m.body.indexOf(",") >= 0;
-		if (!isSequence && !isOptions) {
-			if (m.post.match(/,(?!,).*\}/)) {
-				str = m.pre + "{" + m.body + escClose + m.post;
-				isTop = true;
-				continue;
-			}
-			return [str];
-		}
-		const post = m.post.length ? expand_(m.post, max, false) : [""];
-		let n;
-		if (isSequence) n = m.body.split(/\.\./);
-		else {
-			n = parseCommaParts(m.body);
-			if (n.length === 1 && n[0] !== void 0) {
-				n = expand_(n[0], max, false).map(embrace);
-				/* c8 ignore start */
-				if (n.length === 1) return post.map((p) => m.pre + n[0] + p);
-			}
-		}
-		let N;
-		if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-			const x = numeric(n[0]);
-			const y = numeric(n[1]);
-			const width = Math.max(n[0].length, n[1].length);
-			let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
-			let test = lte;
-			if (y < x) {
-				incr *= -1;
-				test = gte;
-			}
-			const pad = n.some(isPadded);
-			N = [];
-			for (let i = x; test(i, y) && N.length < max; i += incr) {
-				let c;
-				if (isAlphaSequence) {
-					c = String.fromCharCode(i);
-					if (c === "\\") c = "";
-				} else {
-					c = String(i);
-					if (pad) {
-						const need = width - c.length;
-						if (need > 0) {
-							const z = new Array(need + 1).join("0");
-							if (i < 0) c = "-" + z + c.slice(1);
-							else c = z + c;
-						}
-					}
-				}
-				N.push(c);
-			}
-		} else {
-			N = [];
-			for (let j = 0; j < n.length; j++) N.push.apply(N, expand_(n[j], max, false));
-		}
-		for (let j = 0; j < N.length; j++) for (let k = 0; k < post.length && expansions.length < max; k++) {
-			const expansion = pre + N[j] + post[k];
-			if (!isTop || isSequence || expansion) expansions.push(expansion);
-		}
-		return expansions;
-	}
-}
-//#endregion
-export { EXPANSION_MAX, expand };
-//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/brace-expansion@5.0.7/node_modules/brace-expansion/dist/esm/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/brace-expansion@5.0.7/node_modules/brace-expansion/dist/esm/index.js"],"sourcesContent":["import { balanced } from 'balanced-match';\nconst escSlash = '\\0SLASH' + Math.random() + '\\0';\nconst escOpen = '\\0OPEN' + Math.random() + '\\0';\nconst escClose = '\\0CLOSE' + Math.random() + '\\0';\nconst escComma = '\\0COMMA' + Math.random() + '\\0';\nconst escPeriod = '\\0PERIOD' + Math.random() + '\\0';\nconst escSlashPattern = new RegExp(escSlash, 'g');\nconst escOpenPattern = new RegExp(escOpen, 'g');\nconst escClosePattern = new RegExp(escClose, 'g');\nconst escCommaPattern = new RegExp(escComma, 'g');\nconst escPeriodPattern = new RegExp(escPeriod, 'g');\nconst slashPattern = /\\\\\\\\/g;\nconst openPattern = /\\\\{/g;\nconst closePattern = /\\\\}/g;\nconst commaPattern = /\\\\,/g;\nconst periodPattern = /\\\\\\./g;\nexport const EXPANSION_MAX = 100_000;\nfunction numeric(str) {\n return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);\n}\nfunction escapeBraces(str) {\n return str\n .replace(slashPattern, escSlash)\n .replace(openPattern, escOpen)\n .replace(closePattern, escClose)\n .replace(commaPattern, escComma)\n .replace(periodPattern, escPeriod);\n}\nfunction unescapeBraces(str) {\n return str\n .replace(escSlashPattern, '\\\\')\n .replace(escOpenPattern, '{')\n .replace(escClosePattern, '}')\n .replace(escCommaPattern, ',')\n .replace(escPeriodPattern, '.');\n}\n/**\n * Basically just str.split(\",\"), but handling cases\n * where we have nested braced sections, which should be\n * treated as individual members, like {a,{b,c},d}\n */\nfunction parseCommaParts(str) {\n if (!str) {\n return [''];\n }\n const parts = [];\n const m = balanced('{', '}', str);\n if (!m) {\n return str.split(',');\n }\n const { pre, body, post } = m;\n const p = pre.split(',');\n p[p.length - 1] += '{' + body + '}';\n const postParts = parseCommaParts(post);\n if (post.length) {\n ;\n p[p.length - 1] += postParts.shift();\n p.push.apply(p, postParts);\n }\n parts.push.apply(parts, p);\n return parts;\n}\nexport function expand(str, options = {}) {\n if (!str) {\n return [];\n }\n const { max = EXPANSION_MAX } = options;\n // I don't know why Bash 4.3 does this, but it does.\n // Anything starting with {} will have the first two bytes preserved\n // but *only* at the top level, so {},a}b will not expand to anything,\n // but a{},b}c will be expanded to [a}c,abc].\n // One could argue that this is a bug in Bash, but since the goal of\n // this module is to match Bash's rules, we escape a leading {}\n if (str.slice(0, 2) === '{}') {\n str = '\\\\{\\\\}' + str.slice(2);\n }\n return expand_(escapeBraces(str), max, true).map(unescapeBraces);\n}\nfunction embrace(str) {\n return '{' + str + '}';\n}\nfunction isPadded(el) {\n return /^-?0\\d/.test(el);\n}\nfunction lte(i, y) {\n return i <= y;\n}\nfunction gte(i, y) {\n return i >= y;\n}\nfunction expand_(str, max, isTop) {\n /** @type {string[]} */\n const expansions = [];\n // The `{a},b}` rewrite below restarts expansion on a rewritten string with\n // the same `max` and `isTop = true`. Loop instead of recursing so a long run\n // of non-expanding `{}` groups can't exhaust the call stack.\n for (;;) {\n const m = balanced('{', '}', str);\n if (!m)\n return [str];\n // no need to expand pre, since it is guaranteed to be free of brace-sets\n const pre = m.pre;\n if (/\\$$/.test(m.pre)) {\n const post = m.post.length ? expand_(m.post, max, false) : [''];\n for (let k = 0; k < post.length && k < max; k++) {\n const expansion = pre + '{' + m.body + '}' + post[k];\n expansions.push(expansion);\n }\n return expansions;\n }\n const isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n const isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n const isSequence = isNumericSequence || isAlphaSequence;\n const isOptions = m.body.indexOf(',') >= 0;\n if (!isSequence && !isOptions) {\n // {a},b}\n if (m.post.match(/,(?!,).*\\}/)) {\n str = m.pre + '{' + m.body + escClose + m.post;\n isTop = true;\n continue;\n }\n return [str];\n }\n // Only expand post once we know this brace set actually expands. Computing\n // it before the early returns above expanded post a second time on every\n // non-expanding `{}`, which is what made inputs like `a{},{},{}...` blow up\n // exponentially.\n const post = m.post.length ? expand_(m.post, max, false) : [''];\n let n;\n if (isSequence) {\n n = m.body.split(/\\.\\./);\n }\n else {\n n = parseCommaParts(m.body);\n if (n.length === 1 && n[0] !== undefined) {\n // x{{a,b}}y ==> x{a}y x{b}y\n n = expand_(n[0], max, false).map(embrace);\n //XXX is this necessary? Can't seem to hit it in tests.\n /* c8 ignore start */\n if (n.length === 1) {\n return post.map(p => m.pre + n[0] + p);\n }\n /* c8 ignore stop */\n }\n }\n // at this point, n is the parts, and we know it's not a comma set\n // with a single entry.\n let N;\n if (isSequence && n[0] !== undefined && n[1] !== undefined) {\n const x = numeric(n[0]);\n const y = numeric(n[1]);\n const width = Math.max(n[0].length, n[1].length);\n let incr = n.length === 3 && n[2] !== undefined ?\n Math.max(Math.abs(numeric(n[2])), 1)\n : 1;\n let test = lte;\n const reverse = y < x;\n if (reverse) {\n incr *= -1;\n test = gte;\n }\n const pad = n.some(isPadded);\n N = [];\n for (let i = x; test(i, y) && N.length < max; i += incr) {\n let c;\n if (isAlphaSequence) {\n c = String.fromCharCode(i);\n if (c === '\\\\') {\n c = '';\n }\n }\n else {\n c = String(i);\n if (pad) {\n const need = width - c.length;\n if (need > 0) {\n const z = new Array(need + 1).join('0');\n if (i < 0) {\n c = '-' + z + c.slice(1);\n }\n else {\n c = z + c;\n }\n }\n }\n }\n N.push(c);\n }\n }\n else {\n N = [];\n for (let j = 0; j < n.length; j++) {\n N.push.apply(N, expand_(n[j], max, false));\n }\n }\n for (let j = 0; j < N.length; j++) {\n for (let k = 0; k < post.length && expansions.length < max; k++) {\n const expansion = pre + N[j] + post[k];\n if (!isTop || isSequence || expansion) {\n expansions.push(expansion);\n }\n }\n }\n return expansions;\n }\n}\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":"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"}