@savvy-web/pnpm-plugin-silk 0.11.0 → 0.12.0

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 (5) hide show
  1. package/README.md +2 -4
  2. package/index.cjs +29 -11
  3. package/package.json +1 -1
  4. package/pnpmfile.cjs +204 -1690
  5. package/tsdoc-metadata.json +1 -1
package/pnpmfile.cjs CHANGED
@@ -1,1707 +1,221 @@
1
- /*! LICENSE: pnpmfile.cjs.LICENSE.txt */
2
1
  "use strict";
3
- var __webpack_modules__ = {
4
- "./node_modules/.pnpm/parse-gitignore@2.0.0/node_modules/parse-gitignore/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
5
- /*!
6
- * parse-gitignore <https://github.com/jonschlinkert/parse-gitignore>
7
- * Copyright (c) 2015-present, Jon Schlinkert.
8
- * Released under the MIT License.
9
- */ const fs = __webpack_require__("fs");
10
- const isObject = (v)=>null !== v && 'object' == typeof v && !Array.isArray(v);
11
- const INVALID_PATH_CHARS_REGEX = /[<>:"|?*\n\r\t\f\x00-\x1F]/;
12
- const GLOBSTAR_REGEX = /(?:^|\/)[*]{2}($|\/)/;
13
- const MAX_PATH_LENGTH = 248;
14
- const isValidPath = (input)=>{
15
- if ('string' == typeof input) return input.length <= MAX_PATH_LENGTH && !INVALID_PATH_CHARS_REGEX.test(input);
16
- return false;
17
- };
18
- const split = (str)=>String(str).split(/\r\n?|\n/);
19
- const isComment = (str)=>str.startsWith('#');
20
- const isParsed = (input)=>isObject(input) && input.patterns && input.sections;
21
- const patterns = (input)=>split(input).map((l)=>l.trim()).filter((line)=>'' !== line && !isComment(line));
22
- const parse = (input, options = {})=>{
23
- let filepath = options.path;
24
- if (isParsed(input)) return input;
25
- if (isValidPath(input) && fs.existsSync(input)) {
26
- filepath = input;
27
- input = fs.readFileSync(input);
28
- }
29
- const lines = split(input);
30
- const names = new Map();
31
- let parsed = {
32
- sections: [],
33
- patterns: []
34
- };
35
- let section = {
36
- name: 'default',
37
- patterns: []
38
- };
39
- let prev;
40
- for (const line of lines){
41
- const value = line.trim();
42
- if (value.startsWith('#')) {
43
- const [, name] = /^#+\s*(.*)\s*$/.exec(value);
44
- if (prev) {
45
- names.delete(prev.name);
46
- prev.comment += value ? `\n${value}` : '';
47
- prev.name = name ? `${prev.name.trim()}\n${name.trim()}` : prev.name.trim();
48
- names.set(prev.name.toLowerCase().trim(), prev);
49
- continue;
50
- }
51
- section = {
52
- name: name.trim(),
53
- comment: value,
54
- patterns: []
55
- };
56
- names.set(section.name.toLowerCase(), section);
57
- parsed.sections.push(section);
58
- prev = section;
59
- continue;
60
- }
61
- if ('' !== value) {
62
- section.patterns.push(value);
63
- parsed.patterns.push(value);
64
- }
65
- prev = null;
66
- }
67
- if (true === options.dedupe || true === options.unique) parsed = dedupe(parsed, {
68
- ...options,
69
- format: false
70
- });
71
- parsed.path = filepath;
72
- parsed.input = Buffer.from(input);
73
- parsed.format = (opts)=>format(parsed, {
74
- ...options,
75
- ...opts
76
- });
77
- parsed.dedupe = (opts)=>dedupe(parsed, {
78
- ...options,
79
- ...opts
80
- });
81
- parsed.globs = (opts)=>globs(parsed, {
82
- path: filepath,
83
- ...options,
84
- ...opts
85
- });
86
- return parsed;
87
- };
88
- const parseFile = (filepath, options)=>parse(fs.readFileSync(filepath, 'utf8'), options);
89
- const dedupe = (input, options)=>{
90
- const parsed = parse(input, {
91
- ...options,
92
- dedupe: false
93
- });
94
- const names = new Map();
95
- const res = {
96
- sections: [],
97
- patterns: new Set()
98
- };
99
- let current;
100
- for (const section of parsed.sections){
101
- const { name = '', comment, patterns } = section;
102
- const key = name.trim().toLowerCase();
103
- for (const pattern of patterns)res.patterns.add(pattern);
104
- if (name && names.has(key)) {
105
- current = names.get(key);
106
- current.patterns = [
107
- ...current.patterns,
108
- ...patterns
109
- ];
110
- } else {
111
- current = {
112
- name,
113
- comment,
114
- patterns
115
- };
116
- res.sections.push(current);
117
- names.set(key, current);
118
- }
119
- }
120
- for (const section of res.sections)section.patterns = [
121
- ...new Set(section.patterns)
122
- ];
123
- res.patterns = [
124
- ...res.patterns
125
- ];
126
- return res;
127
- };
128
- const glob = (pattern, options)=>{
129
- if (GLOBSTAR_REGEX.test(pattern)) return pattern;
130
- let relative = false;
131
- if (pattern.startsWith('/')) {
132
- pattern = pattern.slice(1);
133
- relative = true;
134
- } else if (pattern.slice(1, pattern.length - 1).includes('/')) relative = true;
135
- pattern += pattern.endsWith('/') ? '**/' : '/**';
136
- return relative ? pattern : `**/${pattern}`;
137
- };
138
- const globs = (input, options = {})=>{
139
- const parsed = parse(input, options);
140
- const result = [];
141
- let index = 0;
142
- const patterns = parsed.patterns.concat(options.ignore || []).concat((options.unignore || []).map((p)=>p.startsWith('!') ? p : '!' + p));
143
- const push = (prefix, pattern)=>{
144
- const prev = result[result.length - 1];
145
- const type = prefix ? 'unignore' : 'ignore';
146
- if (prev && prev.type === type) {
147
- if (!prev.patterns.includes(pattern)) prev.patterns.push(pattern);
148
- } else {
149
- result.push({
150
- type,
151
- path: options.path || null,
152
- patterns: [
153
- pattern
154
- ],
155
- index
156
- });
157
- index++;
158
- }
159
- };
160
- for (let pattern of patterns){
161
- let prefix = '';
162
- if (pattern.startsWith('!')) {
163
- pattern = pattern.slice(1);
164
- prefix = '!';
165
- }
166
- push(prefix, pattern.startsWith('/') ? pattern.slice(1) : pattern);
167
- push(prefix, glob(pattern));
168
- }
169
- return result;
170
- };
171
- const formatSection = (section = {})=>{
172
- const output = [
173
- section.comment || ''
174
- ];
175
- if (section.patterns?.length) {
176
- output.push(section.patterns.join('\n'));
177
- output.push('');
178
- }
179
- return output.join('\n');
180
- };
181
- const format = (input, options = {})=>{
182
- const parsed = parse(input, options);
183
- const fn = options.formatSection || formatSection;
184
- const sections = parsed.sections || parsed;
185
- const output = [];
186
- for (const section of [].concat(sections))output.push(fn(section));
187
- return output.join('\n');
188
- };
189
- parse.file = parseFile;
190
- parse.parse = parse;
191
- parse.dedupe = dedupe;
192
- parse.format = format;
193
- parse.globs = globs;
194
- parse.formatSection = formatSection;
195
- parse.patterns = patterns;
196
- module1.exports = parse;
2
+ var __webpack_exports__ = {};
3
+ const silkCatalogs = {
4
+ silk: {
5
+ "@effect/ai": "^0.35.0",
6
+ "@effect/ai-amazon-bedrock": "^0.15.0",
7
+ "@effect/ai-anthropic": "^0.25.0",
8
+ "@effect/ai-google": "^0.14.0",
9
+ "@effect/ai-openai": "^0.39.0",
10
+ "@effect/cli": "^0.75.0",
11
+ "@effect/cluster": "^0.58.0",
12
+ "@effect/experimental": "^0.60.0",
13
+ "@effect/language-service": "^0.85.1",
14
+ "@effect/opentelemetry": "^0.63.0",
15
+ "@effect/platform": "^0.96.0",
16
+ "@effect/platform-browser": "^0.76.0",
17
+ "@effect/platform-bun": "^0.89.0",
18
+ "@effect/platform-node": "^0.106.0",
19
+ "@effect/platform-node-shared": "^0.59.0",
20
+ "@effect/printer": "^0.49.0",
21
+ "@effect/printer-ansi": "^0.49.0",
22
+ "@effect/rpc": "^0.75.0",
23
+ "@effect/sql": "^0.51.0",
24
+ "@effect/sql-pg": "^0.52.1",
25
+ "@effect/sql-sqlite-bun": "^0.52.0",
26
+ "@effect/sql-sqlite-node": "^0.52.0",
27
+ "@effect/typeclass": "^0.40.0",
28
+ "@effect/workflow": "^0.18.0",
29
+ "@types/node": "^25.5.0",
30
+ "@types/react": "^19.2.14",
31
+ "@types/react-dom": "^19.2.3",
32
+ "@typescript/native-preview": "^7.0.0-dev.20260414.1",
33
+ effect: "^3.21.0",
34
+ react: "^19.2.5",
35
+ "react-dom": "^19.2.5",
36
+ tsx: "^4.21.0",
37
+ typescript: "^6.0.2"
197
38
  },
198
- fs (module1) {
199
- module1.exports = require("fs");
200
- }
39
+ silkPeers: {
40
+ "@effect/ai": ">=0.35.0",
41
+ "@effect/ai-amazon-bedrock": ">=0.15.0",
42
+ "@effect/ai-anthropic": ">=0.25.0",
43
+ "@effect/ai-google": ">=0.14.0",
44
+ "@effect/ai-openai": ">=0.39.0",
45
+ "@effect/cli": ">=0.75.0",
46
+ "@effect/cluster": ">=0.58.0",
47
+ "@effect/experimental": ">=0.60.0",
48
+ "@effect/language-service": ">=0.85.1",
49
+ "@effect/opentelemetry": ">=0.63.0",
50
+ "@effect/platform": ">=0.96.0",
51
+ "@effect/platform-browser": ">=0.76.0",
52
+ "@effect/platform-bun": ">=0.89.0",
53
+ "@effect/platform-node": ">=0.106.0",
54
+ "@effect/platform-node-shared": ">=0.59.0",
55
+ "@effect/printer": ">=0.49.0",
56
+ "@effect/printer-ansi": ">=0.49.0",
57
+ "@effect/rpc": ">=0.75.0",
58
+ "@effect/sql": ">=0.51.0",
59
+ "@effect/sql-pg": ">=0.52.1",
60
+ "@effect/sql-sqlite-bun": ">=0.52.0",
61
+ "@effect/sql-sqlite-node": ">=0.52.0",
62
+ "@effect/typeclass": ">=0.40.0",
63
+ "@effect/workflow": ">=0.18.0",
64
+ "@types/node": "^25.6.0",
65
+ "@types/react": "^19.2.0",
66
+ "@types/react-dom": "^19.2.0",
67
+ "@typescript/native-preview": "^7.0.0-dev.20260124.1",
68
+ effect: ">=3.21.0",
69
+ react: "^19.2.0",
70
+ "react-dom": "^19.2.0",
71
+ tsx: "^4.21.0",
72
+ typescript: "^6.0.0"
73
+ },
74
+ silkOverrides: {
75
+ "@isaacs/brace-expansion": "^5.0.1",
76
+ lodash: "^4.17.23",
77
+ "markdown-it": "^14.1.1",
78
+ minimatch: ">=10.2.3",
79
+ "smol-toml": ">=1.6.1",
80
+ tmp: "^0.2.4"
81
+ },
82
+ silkOnlyBuiltDependencies: [
83
+ "@parcel/watcher",
84
+ "@savvy-web/changesets",
85
+ "@savvy-web/commitlint",
86
+ "@savvy-web/github-action-builder",
87
+ "@savvy-web/lint-staged",
88
+ "@savvy-web/vitest",
89
+ "better-sqlite3",
90
+ "core-js",
91
+ "esbuild",
92
+ "msgpackr-extract"
93
+ ],
94
+ silkPublicHoistPattern: [
95
+ "@changesets/cli",
96
+ "@commitlint/cli",
97
+ "@commitlint/config-conventional",
98
+ "@commitlint/cz-commitlint",
99
+ "@rslib/core",
100
+ "@types/bun",
101
+ "@types/node",
102
+ "@types/react",
103
+ "@types/react-dom",
104
+ "@typescript/native-preview",
105
+ "@vitest/coverage-v8",
106
+ "commitizen",
107
+ "husky",
108
+ "lint-staged",
109
+ "markdownlint-cli2",
110
+ "markdownlint-cli2-formatter-codequality",
111
+ "tsx",
112
+ "turbo",
113
+ "typescript",
114
+ "vitest",
115
+ "vitest-agent-reporter"
116
+ ]
201
117
  };
202
- var __webpack_module_cache__ = {};
203
- function __webpack_require__(moduleId) {
204
- var cachedModule = __webpack_module_cache__[moduleId];
205
- if (void 0 !== cachedModule) return cachedModule.exports;
206
- var module1 = __webpack_module_cache__[moduleId] = {
207
- exports: {}
208
- };
209
- __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
210
- return module1.exports;
118
+ const WARNING_BOX_WIDTH = 75;
119
+ function formatOverrideWarning(overrides) {
120
+ if (0 === overrides.length) return "";
121
+ const lines = [];
122
+ const border = "─".repeat(WARNING_BOX_WIDTH - 2);
123
+ lines.push(`┌${border}┐`);
124
+ lines.push(`│ ⚠️ SILK CATALOG OVERRIDE DETECTED${" ".repeat(WARNING_BOX_WIDTH - 39)}│`);
125
+ lines.push(`├${border}┤`);
126
+ lines.push(`│ The following entries override Silk-managed versions:${" ".repeat(WARNING_BOX_WIDTH - 58)}│`);
127
+ lines.push(`│${" ".repeat(WARNING_BOX_WIDTH - 2)}│`);
128
+ for (const override of overrides){
129
+ const catalogPath = `catalogs.${override.catalog}.${override.package}`;
130
+ const silkLine = ` Silk version: ${override.silkVersion}`;
131
+ const localLine = ` Local override: ${override.localVersion}`;
132
+ lines.push(`│ ${catalogPath}${" ".repeat(WARNING_BOX_WIDTH - catalogPath.length - 4)}│`);
133
+ lines.push(`│${silkLine}${" ".repeat(WARNING_BOX_WIDTH - silkLine.length - 2)}│`);
134
+ lines.push(`│${localLine}${" ".repeat(WARNING_BOX_WIDTH - localLine.length - 2)}│`);
135
+ lines.push(`│${" ".repeat(WARNING_BOX_WIDTH - 2)}│`);
136
+ }
137
+ lines.push(`│ Local versions will be used. To use Silk defaults, remove these${" ".repeat(WARNING_BOX_WIDTH - 69)}│`);
138
+ lines.push(`│ entries from your pnpm-workspace.yaml catalogs section.${" ".repeat(WARNING_BOX_WIDTH - 62)}│`);
139
+ lines.push(`└${border}┘`);
140
+ return lines.join("\n");
211
141
  }
212
- (()=>{
213
- __webpack_require__.n = (module1)=>{
214
- var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
215
- __webpack_require__.d(getter, {
216
- a: getter
217
- });
218
- return getter;
142
+ function warnOverrides(overrides) {
143
+ if (overrides.length > 0) console.warn(formatOverrideWarning(overrides));
144
+ }
145
+ function mergeSingleCatalog(catalogName, silkCatalog, localCatalog, overrides) {
146
+ const merged = {
147
+ ...silkCatalog
219
148
  };
220
- })();
221
- (()=>{
222
- __webpack_require__.d = (exports1, definition)=>{
223
- for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
224
- enumerable: true,
225
- get: definition[key]
149
+ if (!localCatalog) return merged;
150
+ for (const [pkg, localVersion] of Object.entries(localCatalog)){
151
+ const silkVersion = silkCatalog[pkg];
152
+ if (void 0 !== silkVersion && silkVersion !== localVersion) overrides.push({
153
+ catalog: catalogName,
154
+ package: pkg,
155
+ silkVersion,
156
+ localVersion
226
157
  });
227
- };
228
- })();
229
- (()=>{
230
- __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
231
- })();
232
- var __webpack_exports__ = {};
233
- (()=>{
234
- const silkCatalogs = {
235
- silk: {
236
- "@biomejs/biome": "2.4.9",
237
- "@effect/ai": "^0.35.0",
238
- "@effect/ai-anthropic": "^0.25.0",
239
- "@effect/ai-openai": "^0.39.0",
240
- "@effect/cli": "^0.75.0",
241
- "@effect/cluster": "^0.58.0",
242
- "@effect/experimental": "^0.60.0",
243
- "@effect/language-service": "^0.84.0",
244
- "@effect/opentelemetry": "^0.63.0",
245
- "@effect/platform": "^0.96.0",
246
- "@effect/platform-bun": "^0.89.0",
247
- "@effect/platform-node": "^0.106.0",
248
- "@effect/printer": "^0.49.0",
249
- "@effect/printer-ansi": "^0.49.0",
250
- "@effect/rpc": "^0.75.0",
251
- "@effect/sql": "^0.51.0",
252
- "@effect/sql-sqlite-node": "^0.52.0",
253
- "@effect/typeclass": "^0.40.0",
254
- "@effect/workflow": "^0.18.0",
255
- "@types/node": "^25.5.0",
256
- "@typescript/native-preview": "^7.0.0-dev.20260327.2",
257
- effect: "^3.21.0",
258
- husky: "^9.1.7",
259
- tsx: "^4.21.0",
260
- typescript: "^5.9.3"
261
- },
262
- silkPeers: {
263
- "@biomejs/biome": "2.4.9",
264
- "@effect/ai": ">=0.35.0",
265
- "@effect/ai-anthropic": ">=0.25.0",
266
- "@effect/ai-openai": ">=0.39.0",
267
- "@effect/cli": ">=0.75.0",
268
- "@effect/cluster": ">=0.58.0",
269
- "@effect/experimental": ">=0.60.0",
270
- "@effect/language-service": ">=0.84.0",
271
- "@effect/opentelemetry": ">=0.63.0",
272
- "@effect/platform": ">=0.96.0",
273
- "@effect/platform-bun": ">=0.89.0",
274
- "@effect/platform-node": ">=0.106.0",
275
- "@effect/printer": ">=0.49.0",
276
- "@effect/printer-ansi": ">=0.49.0",
277
- "@effect/rpc": ">=0.75.0",
278
- "@effect/sql": ">=0.51.0",
279
- "@effect/sql-sqlite-node": ">=0.52.0",
280
- "@effect/typeclass": ">=0.40.0",
281
- "@effect/workflow": ">=0.18.0",
282
- "@types/node": "^25.5.0",
283
- "@typescript/native-preview": "^7.0.0-dev.20260124.1",
284
- effect: ">=3.21.0",
285
- husky: "^9.1.0",
286
- tsx: "^4.21.0",
287
- typescript: "^5.9.3"
288
- },
289
- silkOverrides: {
290
- "@isaacs/brace-expansion": "^5.0.1",
291
- lodash: "^4.17.23",
292
- "markdown-it": "^14.1.1",
293
- minimatch: ">=10.2.3",
294
- "smol-toml": ">=1.6.1",
295
- tmp: "^0.2.4"
296
- },
297
- silkOnlyBuiltDependencies: [
298
- "@parcel/watcher",
299
- "@savvy-web/changesets",
300
- "@savvy-web/commitlint",
301
- "@savvy-web/github-action-builder",
302
- "@savvy-web/lint-staged",
303
- "@savvy-web/vitest",
304
- "better-sqlite3",
305
- "core-js",
306
- "esbuild",
307
- "msgpackr-extract"
308
- ],
309
- silkPublicHoistPattern: [
310
- "@changesets/cli",
311
- "@commitlint/cli",
312
- "@commitlint/config-conventional",
313
- "@commitlint/cz-commitlint",
314
- "@microsoft/api-extractor",
315
- "@rslib/core",
316
- "@types/node",
317
- "@typescript/native-preview",
318
- "@vitest/coverage-v8",
319
- "commitizen",
320
- "husky",
321
- "lint-staged",
322
- "markdownlint-cli2",
323
- "markdownlint-cli2-formatter-codequality",
324
- "tsx",
325
- "turbo",
326
- "typescript",
327
- "vitest",
328
- "vitest-agent-reporter"
329
- ]
330
- };
331
- const promises_namespaceObject = require("node:fs/promises");
332
- const external_node_path_namespaceObject = require("node:path");
333
- function createScanner(text, ignoreTrivia = false) {
334
- const len = text.length;
335
- let pos = 0, value = '', tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
336
- function scanHexDigits(count, exact) {
337
- let digits = 0;
338
- let value = 0;
339
- while(digits < count || !exact){
340
- let ch = text.charCodeAt(pos);
341
- if (ch >= 48 && ch <= 57) value = 16 * value + ch - 48;
342
- else if (ch >= 65 && ch <= 70) value = 16 * value + ch - 65 + 10;
343
- else if (ch >= 97 && ch <= 102) value = 16 * value + ch - 97 + 10;
344
- else break;
345
- pos++;
346
- digits++;
347
- }
348
- if (digits < count) value = -1;
349
- return value;
350
- }
351
- function setPosition(newPosition) {
352
- pos = newPosition;
353
- value = '';
354
- tokenOffset = 0;
355
- token = 16;
356
- scanError = 0;
357
- }
358
- function scanNumber() {
359
- let start = pos;
360
- if (48 === text.charCodeAt(pos)) pos++;
361
- else {
362
- pos++;
363
- while(pos < text.length && isDigit(text.charCodeAt(pos)))pos++;
364
- }
365
- if (pos < text.length && 46 === text.charCodeAt(pos)) {
366
- pos++;
367
- if (pos < text.length && isDigit(text.charCodeAt(pos))) {
368
- pos++;
369
- while(pos < text.length && isDigit(text.charCodeAt(pos)))pos++;
370
- } else {
371
- scanError = 3;
372
- return text.substring(start, pos);
373
- }
374
- }
375
- let end = pos;
376
- if (pos < text.length && (69 === text.charCodeAt(pos) || 101 === text.charCodeAt(pos))) {
377
- pos++;
378
- if (pos < text.length && 43 === text.charCodeAt(pos) || 45 === text.charCodeAt(pos)) pos++;
379
- if (pos < text.length && isDigit(text.charCodeAt(pos))) {
380
- pos++;
381
- while(pos < text.length && isDigit(text.charCodeAt(pos)))pos++;
382
- end = pos;
383
- } else scanError = 3;
384
- }
385
- return text.substring(start, end);
386
- }
387
- function scanString() {
388
- let result = '', start = pos;
389
- while(true){
390
- if (pos >= len) {
391
- result += text.substring(start, pos);
392
- scanError = 2;
393
- break;
394
- }
395
- const ch = text.charCodeAt(pos);
396
- if (34 === ch) {
397
- result += text.substring(start, pos);
398
- pos++;
399
- break;
400
- }
401
- if (92 === ch) {
402
- result += text.substring(start, pos);
403
- pos++;
404
- if (pos >= len) {
405
- scanError = 2;
406
- break;
407
- }
408
- const ch2 = text.charCodeAt(pos++);
409
- switch(ch2){
410
- case 34:
411
- result += '\"';
412
- break;
413
- case 92:
414
- result += '\\';
415
- break;
416
- case 47:
417
- result += '/';
418
- break;
419
- case 98:
420
- result += '\b';
421
- break;
422
- case 102:
423
- result += '\f';
424
- break;
425
- case 110:
426
- result += '\n';
427
- break;
428
- case 114:
429
- result += '\r';
430
- break;
431
- case 116:
432
- result += '\t';
433
- break;
434
- case 117:
435
- const ch3 = scanHexDigits(4, true);
436
- if (ch3 >= 0) result += String.fromCharCode(ch3);
437
- else scanError = 4;
438
- break;
439
- default:
440
- scanError = 5;
441
- }
442
- start = pos;
443
- continue;
444
- }
445
- if (ch >= 0 && ch <= 0x1f) if (isLineBreak(ch)) {
446
- result += text.substring(start, pos);
447
- scanError = 2;
448
- break;
449
- } else scanError = 6;
450
- pos++;
451
- }
452
- return result;
453
- }
454
- function scanNext() {
455
- value = '';
456
- scanError = 0;
457
- tokenOffset = pos;
458
- lineStartOffset = lineNumber;
459
- prevTokenLineStartOffset = tokenLineStartOffset;
460
- if (pos >= len) {
461
- tokenOffset = len;
462
- return token = 17;
463
- }
464
- let code = text.charCodeAt(pos);
465
- if (isWhiteSpace(code)) {
466
- do {
467
- pos++;
468
- value += String.fromCharCode(code);
469
- code = text.charCodeAt(pos);
470
- }while (isWhiteSpace(code));
471
- return token = 15;
472
- }
473
- if (isLineBreak(code)) {
474
- pos++;
475
- value += String.fromCharCode(code);
476
- if (13 === code && 10 === text.charCodeAt(pos)) {
477
- pos++;
478
- value += '\n';
479
- }
480
- lineNumber++;
481
- tokenLineStartOffset = pos;
482
- return token = 14;
483
- }
484
- switch(code){
485
- case 123:
486
- pos++;
487
- return token = 1;
488
- case 125:
489
- pos++;
490
- return token = 2;
491
- case 91:
492
- pos++;
493
- return token = 3;
494
- case 93:
495
- pos++;
496
- return token = 4;
497
- case 58:
498
- pos++;
499
- return token = 6;
500
- case 44:
501
- pos++;
502
- return token = 5;
503
- case 34:
504
- pos++;
505
- value = scanString();
506
- return token = 10;
507
- case 47:
508
- const start = pos - 1;
509
- if (47 === text.charCodeAt(pos + 1)) {
510
- pos += 2;
511
- while(pos < len){
512
- if (isLineBreak(text.charCodeAt(pos))) break;
513
- pos++;
514
- }
515
- value = text.substring(start, pos);
516
- return token = 12;
517
- }
518
- if (42 === text.charCodeAt(pos + 1)) {
519
- pos += 2;
520
- const safeLength = len - 1;
521
- let commentClosed = false;
522
- while(pos < safeLength){
523
- const ch = text.charCodeAt(pos);
524
- if (42 === ch && 47 === text.charCodeAt(pos + 1)) {
525
- pos += 2;
526
- commentClosed = true;
527
- break;
528
- }
529
- pos++;
530
- if (isLineBreak(ch)) {
531
- if (13 === ch && 10 === text.charCodeAt(pos)) pos++;
532
- lineNumber++;
533
- tokenLineStartOffset = pos;
534
- }
535
- }
536
- if (!commentClosed) {
537
- pos++;
538
- scanError = 1;
539
- }
540
- value = text.substring(start, pos);
541
- return token = 13;
542
- }
543
- value += String.fromCharCode(code);
544
- pos++;
545
- return token = 16;
546
- case 45:
547
- value += String.fromCharCode(code);
548
- pos++;
549
- if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
550
- case 48:
551
- case 49:
552
- case 50:
553
- case 51:
554
- case 52:
555
- case 53:
556
- case 54:
557
- case 55:
558
- case 56:
559
- case 57:
560
- value += scanNumber();
561
- return token = 11;
562
- default:
563
- while(pos < len && isUnknownContentCharacter(code)){
564
- pos++;
565
- code = text.charCodeAt(pos);
566
- }
567
- if (tokenOffset !== pos) {
568
- value = text.substring(tokenOffset, pos);
569
- switch(value){
570
- case 'true':
571
- return token = 8;
572
- case 'false':
573
- return token = 9;
574
- case 'null':
575
- return token = 7;
576
- }
577
- return token = 16;
578
- }
579
- value += String.fromCharCode(code);
580
- pos++;
581
- return token = 16;
582
- }
583
- }
584
- function isUnknownContentCharacter(code) {
585
- if (isWhiteSpace(code) || isLineBreak(code)) return false;
586
- switch(code){
587
- case 125:
588
- case 93:
589
- case 123:
590
- case 91:
591
- case 34:
592
- case 58:
593
- case 44:
594
- case 47:
595
- return false;
596
- }
597
- return true;
598
- }
599
- function scanNextNonTrivia() {
600
- let result;
601
- do result = scanNext();
602
- while (result >= 12 && result <= 15);
603
- return result;
604
- }
605
- return {
606
- setPosition: setPosition,
607
- getPosition: ()=>pos,
608
- scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
609
- getToken: ()=>token,
610
- getTokenValue: ()=>value,
611
- getTokenOffset: ()=>tokenOffset,
612
- getTokenLength: ()=>pos - tokenOffset,
613
- getTokenStartLine: ()=>lineStartOffset,
614
- getTokenStartCharacter: ()=>tokenOffset - prevTokenLineStartOffset,
615
- getTokenError: ()=>scanError
616
- };
617
- }
618
- function isWhiteSpace(ch) {
619
- return 32 === ch || 9 === ch;
620
- }
621
- function isLineBreak(ch) {
622
- return 10 === ch || 13 === ch;
158
+ merged[pkg] = localVersion;
623
159
  }
624
- function isDigit(ch) {
625
- return ch >= 48 && ch <= 57;
626
- }
627
- var scanner_CharacterCodes;
628
- (function(CharacterCodes) {
629
- CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
630
- CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
631
- CharacterCodes[CharacterCodes["space"] = 32] = "space";
632
- CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
633
- CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
634
- CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
635
- CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
636
- CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
637
- CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
638
- CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
639
- CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
640
- CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
641
- CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
642
- CharacterCodes[CharacterCodes["a"] = 97] = "a";
643
- CharacterCodes[CharacterCodes["b"] = 98] = "b";
644
- CharacterCodes[CharacterCodes["c"] = 99] = "c";
645
- CharacterCodes[CharacterCodes["d"] = 100] = "d";
646
- CharacterCodes[CharacterCodes["e"] = 101] = "e";
647
- CharacterCodes[CharacterCodes["f"] = 102] = "f";
648
- CharacterCodes[CharacterCodes["g"] = 103] = "g";
649
- CharacterCodes[CharacterCodes["h"] = 104] = "h";
650
- CharacterCodes[CharacterCodes["i"] = 105] = "i";
651
- CharacterCodes[CharacterCodes["j"] = 106] = "j";
652
- CharacterCodes[CharacterCodes["k"] = 107] = "k";
653
- CharacterCodes[CharacterCodes["l"] = 108] = "l";
654
- CharacterCodes[CharacterCodes["m"] = 109] = "m";
655
- CharacterCodes[CharacterCodes["n"] = 110] = "n";
656
- CharacterCodes[CharacterCodes["o"] = 111] = "o";
657
- CharacterCodes[CharacterCodes["p"] = 112] = "p";
658
- CharacterCodes[CharacterCodes["q"] = 113] = "q";
659
- CharacterCodes[CharacterCodes["r"] = 114] = "r";
660
- CharacterCodes[CharacterCodes["s"] = 115] = "s";
661
- CharacterCodes[CharacterCodes["t"] = 116] = "t";
662
- CharacterCodes[CharacterCodes["u"] = 117] = "u";
663
- CharacterCodes[CharacterCodes["v"] = 118] = "v";
664
- CharacterCodes[CharacterCodes["w"] = 119] = "w";
665
- CharacterCodes[CharacterCodes["x"] = 120] = "x";
666
- CharacterCodes[CharacterCodes["y"] = 121] = "y";
667
- CharacterCodes[CharacterCodes["z"] = 122] = "z";
668
- CharacterCodes[CharacterCodes["A"] = 65] = "A";
669
- CharacterCodes[CharacterCodes["B"] = 66] = "B";
670
- CharacterCodes[CharacterCodes["C"] = 67] = "C";
671
- CharacterCodes[CharacterCodes["D"] = 68] = "D";
672
- CharacterCodes[CharacterCodes["E"] = 69] = "E";
673
- CharacterCodes[CharacterCodes["F"] = 70] = "F";
674
- CharacterCodes[CharacterCodes["G"] = 71] = "G";
675
- CharacterCodes[CharacterCodes["H"] = 72] = "H";
676
- CharacterCodes[CharacterCodes["I"] = 73] = "I";
677
- CharacterCodes[CharacterCodes["J"] = 74] = "J";
678
- CharacterCodes[CharacterCodes["K"] = 75] = "K";
679
- CharacterCodes[CharacterCodes["L"] = 76] = "L";
680
- CharacterCodes[CharacterCodes["M"] = 77] = "M";
681
- CharacterCodes[CharacterCodes["N"] = 78] = "N";
682
- CharacterCodes[CharacterCodes["O"] = 79] = "O";
683
- CharacterCodes[CharacterCodes["P"] = 80] = "P";
684
- CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
685
- CharacterCodes[CharacterCodes["R"] = 82] = "R";
686
- CharacterCodes[CharacterCodes["S"] = 83] = "S";
687
- CharacterCodes[CharacterCodes["T"] = 84] = "T";
688
- CharacterCodes[CharacterCodes["U"] = 85] = "U";
689
- CharacterCodes[CharacterCodes["V"] = 86] = "V";
690
- CharacterCodes[CharacterCodes["W"] = 87] = "W";
691
- CharacterCodes[CharacterCodes["X"] = 88] = "X";
692
- CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
693
- CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
694
- CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
695
- CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
696
- CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
697
- CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
698
- CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
699
- CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
700
- CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
701
- CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
702
- CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
703
- CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
704
- CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
705
- CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
706
- CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
707
- CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
708
- CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
709
- })(scanner_CharacterCodes || (scanner_CharacterCodes = {}));
710
- const cachedSpaces = new Array(20).fill(0).map((_, index)=>' '.repeat(index));
711
- const maxCachedValues = 200;
712
- const cachedBreakLinesWithSpaces = {
713
- ' ': {
714
- '\n': new Array(maxCachedValues).fill(0).map((_, index)=>'\n' + ' '.repeat(index)),
715
- '\r': new Array(maxCachedValues).fill(0).map((_, index)=>'\r' + ' '.repeat(index)),
716
- '\r\n': new Array(maxCachedValues).fill(0).map((_, index)=>'\r\n' + ' '.repeat(index))
717
- },
718
- '\t': {
719
- '\n': new Array(maxCachedValues).fill(0).map((_, index)=>'\n' + '\t'.repeat(index)),
720
- '\r': new Array(maxCachedValues).fill(0).map((_, index)=>'\r' + '\t'.repeat(index)),
721
- '\r\n': new Array(maxCachedValues).fill(0).map((_, index)=>'\r\n' + '\t'.repeat(index))
722
- }
160
+ return merged;
161
+ }
162
+ function mergeOverrides(silkOverrides, localOverrides, overrideWarnings) {
163
+ const merged = {
164
+ ...silkOverrides
723
165
  };
724
- const supportedEols = [
725
- '\n',
726
- '\r',
727
- '\r\n'
728
- ];
729
- function format(documentText, range, options) {
730
- let initialIndentLevel;
731
- let formatText;
732
- let formatTextStart;
733
- let rangeStart;
734
- let rangeEnd;
735
- if (range) {
736
- rangeStart = range.offset;
737
- rangeEnd = rangeStart + range.length;
738
- formatTextStart = rangeStart;
739
- while(formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1))formatTextStart--;
740
- let endOffset = rangeEnd;
741
- while(endOffset < documentText.length && !isEOL(documentText, endOffset))endOffset++;
742
- formatText = documentText.substring(formatTextStart, endOffset);
743
- initialIndentLevel = computeIndentLevel(formatText, options);
744
- } else {
745
- formatText = documentText;
746
- initialIndentLevel = 0;
747
- formatTextStart = 0;
748
- rangeStart = 0;
749
- rangeEnd = documentText.length;
750
- }
751
- const eol = getEOL(options, documentText);
752
- const eolFastPathSupported = supportedEols.includes(eol);
753
- let numberLineBreaks = 0;
754
- let indentLevel = 0;
755
- let indentValue;
756
- indentValue = options.insertSpaces ? cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces["1"], options.tabSize || 4) : '\t';
757
- const indentType = '\t' === indentValue ? '\t' : ' ';
758
- let scanner = createScanner(formatText, false);
759
- let hasError = false;
760
- function newLinesAndIndent() {
761
- if (numberLineBreaks > 1) return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
762
- const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
763
- if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) return eol + repeat(indentValue, initialIndentLevel + indentLevel);
764
- if (amountOfSpaces <= 0) return eol;
765
- return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
766
- }
767
- function scanNext() {
768
- let token = scanner.scan();
769
- numberLineBreaks = 0;
770
- while(15 === token || 14 === token){
771
- if (14 === token && options.keepLines) numberLineBreaks += 1;
772
- else if (14 === token) numberLineBreaks = 1;
773
- token = scanner.scan();
774
- }
775
- hasError = 16 === token || 0 !== scanner.getTokenError();
776
- return token;
777
- }
778
- const editOperations = [];
779
- function addEdit(text, startOffset, endOffset) {
780
- if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) editOperations.push({
781
- offset: startOffset,
782
- length: endOffset - startOffset,
783
- content: text
784
- });
785
- }
786
- let firstToken = scanNext();
787
- if (options.keepLines && numberLineBreaks > 0) addEdit(repeat(eol, numberLineBreaks), 0, 0);
788
- if (17 !== firstToken) {
789
- let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
790
- let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
791
- addEdit(initialIndent, formatTextStart, firstTokenStart);
792
- }
793
- while(17 !== firstToken){
794
- let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
795
- let secondToken = scanNext();
796
- let replaceContent = '';
797
- let needsLineBreak = false;
798
- while(0 === numberLineBreaks && (12 === secondToken || 13 === secondToken)){
799
- let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
800
- addEdit(cachedSpaces["1"], firstTokenEnd, commentTokenStart);
801
- firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
802
- needsLineBreak = 12 === secondToken;
803
- replaceContent = needsLineBreak ? newLinesAndIndent() : '';
804
- secondToken = scanNext();
805
- }
806
- if (2 === secondToken) {
807
- if (1 !== firstToken) indentLevel--;
808
- if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && 1 !== firstToken) replaceContent = newLinesAndIndent();
809
- else if (options.keepLines) replaceContent = cachedSpaces["1"];
810
- } else if (4 === secondToken) {
811
- if (3 !== firstToken) indentLevel--;
812
- if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && 3 !== firstToken) replaceContent = newLinesAndIndent();
813
- else if (options.keepLines) replaceContent = cachedSpaces["1"];
814
- } else {
815
- switch(firstToken){
816
- case 3:
817
- case 1:
818
- indentLevel++;
819
- replaceContent = options.keepLines && numberLineBreaks > 0 || !options.keepLines ? newLinesAndIndent() : cachedSpaces["1"];
820
- break;
821
- case 5:
822
- replaceContent = options.keepLines && numberLineBreaks > 0 || !options.keepLines ? newLinesAndIndent() : cachedSpaces["1"];
823
- break;
824
- case 12:
825
- replaceContent = newLinesAndIndent();
826
- break;
827
- case 13:
828
- if (numberLineBreaks > 0) replaceContent = newLinesAndIndent();
829
- else if (!needsLineBreak) replaceContent = cachedSpaces["1"];
830
- break;
831
- case 6:
832
- if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
833
- else if (!needsLineBreak) replaceContent = cachedSpaces["1"];
834
- break;
835
- case 10:
836
- if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
837
- else if (6 === secondToken && !needsLineBreak) replaceContent = '';
838
- break;
839
- case 7:
840
- case 8:
841
- case 9:
842
- case 11:
843
- case 2:
844
- case 4:
845
- if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
846
- else if (12 !== secondToken && 13 !== secondToken || needsLineBreak) {
847
- if (5 !== secondToken && 17 !== secondToken) hasError = true;
848
- } else replaceContent = cachedSpaces["1"];
849
- break;
850
- case 16:
851
- hasError = true;
852
- break;
853
- }
854
- if (numberLineBreaks > 0 && (12 === secondToken || 13 === secondToken)) replaceContent = newLinesAndIndent();
855
- }
856
- if (17 === secondToken) replaceContent = options.keepLines && numberLineBreaks > 0 ? newLinesAndIndent() : options.insertFinalNewline ? eol : '';
857
- const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
858
- addEdit(replaceContent, firstTokenEnd, secondTokenStart);
859
- firstToken = secondToken;
860
- }
861
- return editOperations;
862
- }
863
- function repeat(s, count) {
864
- let result = '';
865
- for(let i = 0; i < count; i++)result += s;
866
- return result;
867
- }
868
- function computeIndentLevel(content, options) {
869
- let i = 0;
870
- let nChars = 0;
871
- const tabSize = options.tabSize || 4;
872
- while(i < content.length){
873
- let ch = content.charAt(i);
874
- if (ch === cachedSpaces["1"]) nChars++;
875
- else if ('\t' === ch) nChars += tabSize;
876
- else break;
877
- i++;
878
- }
879
- return Math.floor(nChars / tabSize);
880
- }
881
- function getEOL(options, text) {
882
- for(let i = 0; i < text.length; i++){
883
- const ch = text.charAt(i);
884
- if ('\r' === ch) {
885
- if (i + 1 < text.length && '\n' === text.charAt(i + 1)) return '\r\n';
886
- return '\r';
887
- }
888
- if ('\n' === ch) return '\n';
889
- }
890
- return options && options.eol || '\n';
891
- }
892
- function isEOL(text, offset) {
893
- return -1 !== '\r\n'.indexOf(text.charAt(offset));
894
- }
895
- var parser_ParseOptions;
896
- (function(ParseOptions) {
897
- ParseOptions.DEFAULT = {
898
- allowTrailingComma: false
899
- };
900
- })(parser_ParseOptions || (parser_ParseOptions = {}));
901
- function parse(text, errors = [], options = parser_ParseOptions.DEFAULT) {
902
- let currentProperty = null;
903
- let currentParent = [];
904
- const previousParents = [];
905
- function onValue(value) {
906
- if (Array.isArray(currentParent)) currentParent.push(value);
907
- else if (null !== currentProperty) currentParent[currentProperty] = value;
908
- }
909
- const visitor = {
910
- onObjectBegin: ()=>{
911
- const object = {};
912
- onValue(object);
913
- previousParents.push(currentParent);
914
- currentParent = object;
915
- currentProperty = null;
916
- },
917
- onObjectProperty: (name)=>{
918
- currentProperty = name;
919
- },
920
- onObjectEnd: ()=>{
921
- currentParent = previousParents.pop();
922
- },
923
- onArrayBegin: ()=>{
924
- const array = [];
925
- onValue(array);
926
- previousParents.push(currentParent);
927
- currentParent = array;
928
- currentProperty = null;
929
- },
930
- onArrayEnd: ()=>{
931
- currentParent = previousParents.pop();
932
- },
933
- onLiteralValue: onValue,
934
- onError: (error, offset, length)=>{
935
- errors.push({
936
- error,
937
- offset,
938
- length
939
- });
940
- }
941
- };
942
- visit(text, visitor, options);
943
- return currentParent[0];
944
- }
945
- function parseTree(text, errors = [], options = parser_ParseOptions.DEFAULT) {
946
- let currentParent = {
947
- type: 'array',
948
- offset: -1,
949
- length: -1,
950
- children: [],
951
- parent: void 0
952
- };
953
- function ensurePropertyComplete(endOffset) {
954
- if ('property' === currentParent.type) {
955
- currentParent.length = endOffset - currentParent.offset;
956
- currentParent = currentParent.parent;
957
- }
958
- }
959
- function onValue(valueNode) {
960
- currentParent.children.push(valueNode);
961
- return valueNode;
962
- }
963
- const visitor = {
964
- onObjectBegin: (offset)=>{
965
- currentParent = onValue({
966
- type: 'object',
967
- offset,
968
- length: -1,
969
- parent: currentParent,
970
- children: []
971
- });
972
- },
973
- onObjectProperty: (name, offset, length)=>{
974
- currentParent = onValue({
975
- type: 'property',
976
- offset,
977
- length: -1,
978
- parent: currentParent,
979
- children: []
980
- });
981
- currentParent.children.push({
982
- type: 'string',
983
- value: name,
984
- offset,
985
- length,
986
- parent: currentParent
987
- });
988
- },
989
- onObjectEnd: (offset, length)=>{
990
- ensurePropertyComplete(offset + length);
991
- currentParent.length = offset + length - currentParent.offset;
992
- currentParent = currentParent.parent;
993
- ensurePropertyComplete(offset + length);
994
- },
995
- onArrayBegin: (offset, length)=>{
996
- currentParent = onValue({
997
- type: 'array',
998
- offset,
999
- length: -1,
1000
- parent: currentParent,
1001
- children: []
1002
- });
1003
- },
1004
- onArrayEnd: (offset, length)=>{
1005
- currentParent.length = offset + length - currentParent.offset;
1006
- currentParent = currentParent.parent;
1007
- ensurePropertyComplete(offset + length);
1008
- },
1009
- onLiteralValue: (value, offset, length)=>{
1010
- onValue({
1011
- type: getNodeType(value),
1012
- offset,
1013
- length,
1014
- parent: currentParent,
1015
- value
1016
- });
1017
- ensurePropertyComplete(offset + length);
1018
- },
1019
- onSeparator: (sep, offset, length)=>{
1020
- if ('property' === currentParent.type) {
1021
- if (':' === sep) currentParent.colonOffset = offset;
1022
- else if (',' === sep) ensurePropertyComplete(offset);
1023
- }
1024
- },
1025
- onError: (error, offset, length)=>{
1026
- errors.push({
1027
- error,
1028
- offset,
1029
- length
1030
- });
1031
- }
1032
- };
1033
- visit(text, visitor, options);
1034
- const result = currentParent.children[0];
1035
- if (result) delete result.parent;
1036
- return result;
1037
- }
1038
- function findNodeAtLocation(root, path) {
1039
- if (!root) return;
1040
- let node = root;
1041
- for (let segment of path)if ('string' == typeof segment) {
1042
- if ('object' !== node.type || !Array.isArray(node.children)) return;
1043
- let found = false;
1044
- for (const propertyNode of node.children)if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && 2 === propertyNode.children.length) {
1045
- node = propertyNode.children[1];
1046
- found = true;
1047
- break;
1048
- }
1049
- if (!found) return;
1050
- } else {
1051
- const index = segment;
1052
- if ('array' !== node.type || index < 0 || !Array.isArray(node.children) || index >= node.children.length) return;
1053
- node = node.children[index];
1054
- }
1055
- return node;
1056
- }
1057
- function visit(text, visitor, options = parser_ParseOptions.DEFAULT) {
1058
- const _scanner = createScanner(text, false);
1059
- const _jsonPath = [];
1060
- let suppressedCallbacks = 0;
1061
- function toNoArgVisit(visitFunction) {
1062
- return visitFunction ? ()=>0 === suppressedCallbacks && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : ()=>true;
1063
- }
1064
- function toOneArgVisit(visitFunction) {
1065
- return visitFunction ? (arg)=>0 === suppressedCallbacks && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : ()=>true;
1066
- }
1067
- function toOneArgVisitWithPath(visitFunction) {
1068
- return visitFunction ? (arg)=>0 === suppressedCallbacks && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), ()=>_jsonPath.slice()) : ()=>true;
1069
- }
1070
- function toBeginVisit(visitFunction) {
1071
- return visitFunction ? ()=>{
1072
- if (suppressedCallbacks > 0) suppressedCallbacks++;
1073
- else {
1074
- let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), ()=>_jsonPath.slice());
1075
- if (false === cbReturn) suppressedCallbacks = 1;
1076
- }
1077
- } : ()=>true;
1078
- }
1079
- function toEndVisit(visitFunction) {
1080
- return visitFunction ? ()=>{
1081
- if (suppressedCallbacks > 0) suppressedCallbacks--;
1082
- if (0 === suppressedCallbacks) visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
1083
- } : ()=>true;
1084
- }
1085
- const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
1086
- const disallowComments = options && options.disallowComments;
1087
- const allowTrailingComma = options && options.allowTrailingComma;
1088
- function scanNext() {
1089
- while(true){
1090
- const token = _scanner.scan();
1091
- switch(_scanner.getTokenError()){
1092
- case 4:
1093
- handleError(14);
1094
- break;
1095
- case 5:
1096
- handleError(15);
1097
- break;
1098
- case 3:
1099
- handleError(13);
1100
- break;
1101
- case 1:
1102
- if (!disallowComments) handleError(11);
1103
- break;
1104
- case 2:
1105
- handleError(12);
1106
- break;
1107
- case 6:
1108
- handleError(16);
1109
- break;
1110
- }
1111
- switch(token){
1112
- case 12:
1113
- case 13:
1114
- if (disallowComments) handleError(10);
1115
- else onComment();
1116
- break;
1117
- case 16:
1118
- handleError(1);
1119
- break;
1120
- case 15:
1121
- case 14:
1122
- break;
1123
- default:
1124
- return token;
1125
- }
1126
- }
1127
- }
1128
- function handleError(error, skipUntilAfter = [], skipUntil = []) {
1129
- onError(error);
1130
- if (skipUntilAfter.length + skipUntil.length > 0) {
1131
- let token = _scanner.getToken();
1132
- while(17 !== token){
1133
- if (-1 !== skipUntilAfter.indexOf(token)) {
1134
- scanNext();
1135
- break;
1136
- }
1137
- if (-1 !== skipUntil.indexOf(token)) break;
1138
- token = scanNext();
1139
- }
1140
- }
1141
- }
1142
- function parseString(isValue) {
1143
- const value = _scanner.getTokenValue();
1144
- if (isValue) onLiteralValue(value);
1145
- else {
1146
- onObjectProperty(value);
1147
- _jsonPath.push(value);
1148
- }
1149
- scanNext();
1150
- return true;
1151
- }
1152
- function parseLiteral() {
1153
- switch(_scanner.getToken()){
1154
- case 11:
1155
- const tokenValue = _scanner.getTokenValue();
1156
- let value = Number(tokenValue);
1157
- if (isNaN(value)) {
1158
- handleError(2);
1159
- value = 0;
1160
- }
1161
- onLiteralValue(value);
1162
- break;
1163
- case 7:
1164
- onLiteralValue(null);
1165
- break;
1166
- case 8:
1167
- onLiteralValue(true);
1168
- break;
1169
- case 9:
1170
- onLiteralValue(false);
1171
- break;
1172
- default:
1173
- return false;
1174
- }
1175
- scanNext();
1176
- return true;
1177
- }
1178
- function parseProperty() {
1179
- if (10 !== _scanner.getToken()) {
1180
- handleError(3, [], [
1181
- 2,
1182
- 5
1183
- ]);
1184
- return false;
1185
- }
1186
- parseString(false);
1187
- if (6 === _scanner.getToken()) {
1188
- onSeparator(':');
1189
- scanNext();
1190
- if (!parseValue()) handleError(4, [], [
1191
- 2,
1192
- 5
1193
- ]);
1194
- } else handleError(5, [], [
1195
- 2,
1196
- 5
1197
- ]);
1198
- _jsonPath.pop();
1199
- return true;
1200
- }
1201
- function parseObject() {
1202
- onObjectBegin();
1203
- scanNext();
1204
- let needsComma = false;
1205
- while(2 !== _scanner.getToken() && 17 !== _scanner.getToken()){
1206
- if (5 === _scanner.getToken()) {
1207
- if (!needsComma) handleError(4, [], []);
1208
- onSeparator(',');
1209
- scanNext();
1210
- if (2 === _scanner.getToken() && allowTrailingComma) break;
1211
- } else if (needsComma) handleError(6, [], []);
1212
- if (!parseProperty()) handleError(4, [], [
1213
- 2,
1214
- 5
1215
- ]);
1216
- needsComma = true;
1217
- }
1218
- onObjectEnd();
1219
- if (2 !== _scanner.getToken()) handleError(7, [
1220
- 2
1221
- ], []);
1222
- else scanNext();
1223
- return true;
1224
- }
1225
- function parseArray() {
1226
- onArrayBegin();
1227
- scanNext();
1228
- let isFirstElement = true;
1229
- let needsComma = false;
1230
- while(4 !== _scanner.getToken() && 17 !== _scanner.getToken()){
1231
- if (5 === _scanner.getToken()) {
1232
- if (!needsComma) handleError(4, [], []);
1233
- onSeparator(',');
1234
- scanNext();
1235
- if (4 === _scanner.getToken() && allowTrailingComma) break;
1236
- } else if (needsComma) handleError(6, [], []);
1237
- if (isFirstElement) {
1238
- _jsonPath.push(0);
1239
- isFirstElement = false;
1240
- } else _jsonPath[_jsonPath.length - 1]++;
1241
- if (!parseValue()) handleError(4, [], [
1242
- 4,
1243
- 5
1244
- ]);
1245
- needsComma = true;
1246
- }
1247
- onArrayEnd();
1248
- if (!isFirstElement) _jsonPath.pop();
1249
- if (4 !== _scanner.getToken()) handleError(8, [
1250
- 4
1251
- ], []);
1252
- else scanNext();
1253
- return true;
1254
- }
1255
- function parseValue() {
1256
- switch(_scanner.getToken()){
1257
- case 3:
1258
- return parseArray();
1259
- case 1:
1260
- return parseObject();
1261
- case 10:
1262
- return parseString(true);
1263
- default:
1264
- return parseLiteral();
1265
- }
1266
- }
1267
- scanNext();
1268
- if (17 === _scanner.getToken()) {
1269
- if (options.allowEmptyContent) return true;
1270
- handleError(4, [], []);
1271
- return false;
1272
- }
1273
- if (!parseValue()) {
1274
- handleError(4, [], []);
1275
- return false;
1276
- }
1277
- if (17 !== _scanner.getToken()) handleError(9, [], []);
1278
- return true;
1279
- }
1280
- function getNodeType(value) {
1281
- switch(typeof value){
1282
- case 'boolean':
1283
- return 'boolean';
1284
- case 'number':
1285
- return 'number';
1286
- case 'string':
1287
- return 'string';
1288
- case 'object':
1289
- if (!value) return 'null';
1290
- if (Array.isArray(value)) return 'array';
1291
- return 'object';
1292
- default:
1293
- return 'null';
1294
- }
1295
- }
1296
- function setProperty(text, originalPath, value, options) {
1297
- const path = originalPath.slice();
1298
- const errors = [];
1299
- const root = parseTree(text, errors);
1300
- let parent;
1301
- let lastSegment;
1302
- while(path.length > 0){
1303
- lastSegment = path.pop();
1304
- parent = findNodeAtLocation(root, path);
1305
- if (void 0 === parent && void 0 !== value) value = 'string' == typeof lastSegment ? {
1306
- [lastSegment]: value
1307
- } : [
1308
- value
1309
- ];
1310
- else break;
1311
- }
1312
- if (parent) if ('object' === parent.type && 'string' == typeof lastSegment && Array.isArray(parent.children)) {
1313
- const existing = findNodeAtLocation(parent, [
1314
- lastSegment
1315
- ]);
1316
- if (void 0 !== existing) if (void 0 !== value) return withFormatting(text, {
1317
- offset: existing.offset,
1318
- length: existing.length,
1319
- content: JSON.stringify(value)
1320
- }, options);
1321
- else {
1322
- if (!existing.parent) throw new Error('Malformed AST');
1323
- const propertyIndex = parent.children.indexOf(existing.parent);
1324
- let removeBegin;
1325
- let removeEnd = existing.parent.offset + existing.parent.length;
1326
- if (propertyIndex > 0) {
1327
- let previous = parent.children[propertyIndex - 1];
1328
- removeBegin = previous.offset + previous.length;
1329
- } else {
1330
- removeBegin = parent.offset + 1;
1331
- if (parent.children.length > 1) {
1332
- let next = parent.children[1];
1333
- removeEnd = next.offset;
1334
- }
1335
- }
1336
- return withFormatting(text, {
1337
- offset: removeBegin,
1338
- length: removeEnd - removeBegin,
1339
- content: ''
1340
- }, options);
1341
- }
1342
- {
1343
- if (void 0 === value) return [];
1344
- const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
1345
- const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p)=>p.children[0].value)) : parent.children.length;
1346
- let edit;
1347
- if (index > 0) {
1348
- let previous = parent.children[index - 1];
1349
- edit = {
1350
- offset: previous.offset + previous.length,
1351
- length: 0,
1352
- content: ',' + newProperty
1353
- };
1354
- } else edit = 0 === parent.children.length ? {
1355
- offset: parent.offset + 1,
1356
- length: 0,
1357
- content: newProperty
1358
- } : {
1359
- offset: parent.offset + 1,
1360
- length: 0,
1361
- content: newProperty + ','
1362
- };
1363
- return withFormatting(text, edit, options);
1364
- }
1365
- } else if ('array' === parent.type && 'number' == typeof lastSegment && Array.isArray(parent.children)) {
1366
- const insertIndex = lastSegment;
1367
- if (-1 === insertIndex) {
1368
- const newProperty = `${JSON.stringify(value)}`;
1369
- let edit;
1370
- if (0 === parent.children.length) edit = {
1371
- offset: parent.offset + 1,
1372
- length: 0,
1373
- content: newProperty
1374
- };
1375
- else {
1376
- const previous = parent.children[parent.children.length - 1];
1377
- edit = {
1378
- offset: previous.offset + previous.length,
1379
- length: 0,
1380
- content: ',' + newProperty
1381
- };
1382
- }
1383
- return withFormatting(text, edit, options);
1384
- }
1385
- if (void 0 === value && parent.children.length >= 0) {
1386
- const removalIndex = lastSegment;
1387
- const toRemove = parent.children[removalIndex];
1388
- let edit;
1389
- if (1 === parent.children.length) edit = {
1390
- offset: parent.offset + 1,
1391
- length: parent.length - 2,
1392
- content: ''
1393
- };
1394
- else if (parent.children.length - 1 === removalIndex) {
1395
- let previous = parent.children[removalIndex - 1];
1396
- let offset = previous.offset + previous.length;
1397
- let parentEndOffset = parent.offset + parent.length;
1398
- edit = {
1399
- offset,
1400
- length: parentEndOffset - 2 - offset,
1401
- content: ''
1402
- };
1403
- } else edit = {
1404
- offset: toRemove.offset,
1405
- length: parent.children[removalIndex + 1].offset - toRemove.offset,
1406
- content: ''
1407
- };
1408
- return withFormatting(text, edit, options);
1409
- }
1410
- if (void 0 !== value) {
1411
- let edit;
1412
- const newProperty = `${JSON.stringify(value)}`;
1413
- if (!options.isArrayInsertion && parent.children.length > lastSegment) {
1414
- const toModify = parent.children[lastSegment];
1415
- edit = {
1416
- offset: toModify.offset,
1417
- length: toModify.length,
1418
- content: newProperty
1419
- };
1420
- } else if (0 === parent.children.length || 0 === lastSegment) edit = {
1421
- offset: parent.offset + 1,
1422
- length: 0,
1423
- content: 0 === parent.children.length ? newProperty : newProperty + ','
1424
- };
1425
- else {
1426
- const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
1427
- const previous = parent.children[index - 1];
1428
- edit = {
1429
- offset: previous.offset + previous.length,
1430
- length: 0,
1431
- content: ',' + newProperty
1432
- };
1433
- }
1434
- return withFormatting(text, edit, options);
1435
- } else throw new Error(`Can not ${void 0 === value ? 'remove' : options.isArrayInsertion ? 'insert' : 'modify'} Array index ${insertIndex} as length is not sufficient`);
1436
- } else throw new Error(`Can not add ${'number' != typeof lastSegment ? 'index' : 'property'} to parent of type ${parent.type}`);
1437
- if (void 0 === value) throw new Error('Can not delete in empty document');
1438
- return withFormatting(text, {
1439
- offset: root ? root.offset : 0,
1440
- length: root ? root.length : 0,
1441
- content: JSON.stringify(value)
1442
- }, options);
1443
- }
1444
- function withFormatting(text, edit, options) {
1445
- if (!options.formattingOptions) return [
1446
- edit
1447
- ];
1448
- let newText = applyEdit(text, edit);
1449
- let begin = edit.offset;
1450
- let end = edit.offset + edit.content.length;
1451
- if (0 === edit.length || 0 === edit.content.length) {
1452
- while(begin > 0 && !isEOL(newText, begin - 1))begin--;
1453
- while(end < newText.length && !isEOL(newText, end))end++;
1454
- }
1455
- const edits = format(newText, {
1456
- offset: begin,
1457
- length: end - begin
1458
- }, {
1459
- ...options.formattingOptions,
1460
- keepLines: false
166
+ if (!localOverrides) return merged;
167
+ for (const [pkg, localVersion] of Object.entries(localOverrides)){
168
+ const silkVersion = silkOverrides[pkg];
169
+ if (void 0 !== silkVersion && silkVersion !== localVersion) overrideWarnings.push({
170
+ catalog: "overrides",
171
+ package: pkg,
172
+ silkVersion,
173
+ localVersion
1461
174
  });
1462
- for(let i = edits.length - 1; i >= 0; i--){
1463
- const edit = edits[i];
1464
- newText = applyEdit(newText, edit);
1465
- begin = Math.min(begin, edit.offset);
1466
- end = Math.max(end, edit.offset + edit.length);
1467
- end += edit.content.length - edit.length;
1468
- }
1469
- const editLength = text.length - (newText.length - end) - begin;
1470
- return [
1471
- {
1472
- offset: begin,
1473
- length: editLength,
1474
- content: newText.substring(begin, end)
1475
- }
1476
- ];
1477
- }
1478
- function applyEdit(text, edit) {
1479
- return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
1480
- }
1481
- var main_ScanError;
1482
- (function(ScanError) {
1483
- ScanError[ScanError["None"] = 0] = "None";
1484
- ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
1485
- ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
1486
- ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
1487
- ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
1488
- ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
1489
- ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
1490
- })(main_ScanError || (main_ScanError = {}));
1491
- var main_SyntaxKind;
1492
- (function(SyntaxKind) {
1493
- SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
1494
- SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
1495
- SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
1496
- SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
1497
- SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
1498
- SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
1499
- SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
1500
- SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
1501
- SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
1502
- SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
1503
- SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
1504
- SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
1505
- SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
1506
- SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
1507
- SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
1508
- SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
1509
- SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
1510
- })(main_SyntaxKind || (main_SyntaxKind = {}));
1511
- const main_parse = parse;
1512
- var main_ParseErrorCode;
1513
- (function(ParseErrorCode) {
1514
- ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
1515
- ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
1516
- ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
1517
- ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
1518
- ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
1519
- ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
1520
- ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
1521
- ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
1522
- ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
1523
- ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
1524
- ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
1525
- ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
1526
- ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
1527
- ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
1528
- ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
1529
- ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
1530
- })(main_ParseErrorCode || (main_ParseErrorCode = {}));
1531
- function modify(text, path, value, options) {
1532
- return setProperty(text, path, value, options);
1533
- }
1534
- function applyEdits(text, edits) {
1535
- let sortedEdits = edits.slice(0).sort((a, b)=>{
1536
- const diff = a.offset - b.offset;
1537
- if (0 === diff) return a.length - b.length;
1538
- return diff;
1539
- });
1540
- let lastModifiedOffset = text.length;
1541
- for(let i = sortedEdits.length - 1; i >= 0; i--){
1542
- let e = sortedEdits[i];
1543
- if (e.offset + e.length <= lastModifiedOffset) text = applyEdit(text, e);
1544
- else throw new Error('Overlapping edit');
1545
- lastModifiedOffset = e.offset;
1546
- }
1547
- return text;
1548
- }
1549
- var parse_gitignore = __webpack_require__("./node_modules/.pnpm/parse-gitignore@2.0.0/node_modules/parse-gitignore/index.js");
1550
- var parse_gitignore_default = /*#__PURE__*/ __webpack_require__.n(parse_gitignore);
1551
- const SCHEMA_URL_PREFIX = "https://biomejs.dev/schemas/";
1552
- const SCHEMA_URL_SUFFIX = "/schema.json";
1553
- const BIOME_GLOB_PATTERN = "**/biome.{json,jsonc}";
1554
- function extractSemver(versionRange) {
1555
- return versionRange.replace(/^[^\d]*/, "");
1556
- }
1557
- async function parseGitignorePatterns(workspaceRoot) {
1558
- try {
1559
- const content = await (0, promises_namespaceObject.readFile)((0, external_node_path_namespaceObject.join)(workspaceRoot, ".gitignore"), "utf-8");
1560
- return parse_gitignore_default()(content).patterns;
1561
- } catch {
1562
- return [];
1563
- }
1564
- }
1565
- async function findBiomeConfigs(workspaceRoot) {
1566
- const ignorePatterns = await parseGitignorePatterns(workspaceRoot);
1567
- const results = [];
1568
- for await (const entry of (0, promises_namespaceObject.glob)(BIOME_GLOB_PATTERN, {
1569
- cwd: workspaceRoot,
1570
- exclude: (name)=>ignorePatterns.some((pattern)=>(0, external_node_path_namespaceObject.matchesGlob)(name, pattern))
1571
- }))results.push(entry);
1572
- return results;
1573
- }
1574
- function buildSchemaUrl(version) {
1575
- return `${SCHEMA_URL_PREFIX}${version}${SCHEMA_URL_SUFFIX}`;
1576
- }
1577
- async function syncBiomeSchema(workspaceRoot, biomeVersion) {
1578
- try {
1579
- const version = extractSemver(biomeVersion);
1580
- const expectedUrl = buildSchemaUrl(version);
1581
- const configs = await findBiomeConfigs(workspaceRoot);
1582
- for (const relativePath of configs){
1583
- const configPath = (0, external_node_path_namespaceObject.join)(workspaceRoot, relativePath);
1584
- const content = await (0, promises_namespaceObject.readFile)(configPath, "utf-8");
1585
- const parsed = main_parse(content);
1586
- if ("string" != typeof parsed?.$schema) continue;
1587
- if (parsed.$schema === expectedUrl) continue;
1588
- if (!parsed.$schema.startsWith(SCHEMA_URL_PREFIX)) continue;
1589
- const edits = modify(content, [
1590
- "$schema"
1591
- ], expectedUrl, {});
1592
- const updated = applyEdits(content, edits);
1593
- await (0, promises_namespaceObject.writeFile)(configPath, updated, "utf-8");
1594
- console.warn(`[pnpm-plugin-silk] Updated biome schema in ${relativePath} to v${version}`);
1595
- }
1596
- } catch (error) {
1597
- console.warn("[pnpm-plugin-silk] Error syncing biome schema:", error instanceof Error ? error.message : String(error));
1598
- }
1599
- }
1600
- const WARNING_BOX_WIDTH = 75;
1601
- function formatOverrideWarning(overrides) {
1602
- if (0 === overrides.length) return "";
1603
- const lines = [];
1604
- const border = "─".repeat(WARNING_BOX_WIDTH - 2);
1605
- lines.push(`┌${border}┐`);
1606
- lines.push(`│ ⚠️ SILK CATALOG OVERRIDE DETECTED${" ".repeat(WARNING_BOX_WIDTH - 39)}│`);
1607
- lines.push(`├${border}┤`);
1608
- lines.push(`│ The following entries override Silk-managed versions:${" ".repeat(WARNING_BOX_WIDTH - 58)}│`);
1609
- lines.push(`│${" ".repeat(WARNING_BOX_WIDTH - 2)}│`);
1610
- for (const override of overrides){
1611
- const catalogPath = `catalogs.${override.catalog}.${override.package}`;
1612
- const silkLine = ` Silk version: ${override.silkVersion}`;
1613
- const localLine = ` Local override: ${override.localVersion}`;
1614
- lines.push(`│ ${catalogPath}${" ".repeat(WARNING_BOX_WIDTH - catalogPath.length - 4)}│`);
1615
- lines.push(`│${silkLine}${" ".repeat(WARNING_BOX_WIDTH - silkLine.length - 2)}│`);
1616
- lines.push(`│${localLine}${" ".repeat(WARNING_BOX_WIDTH - localLine.length - 2)}│`);
1617
- lines.push(`│${" ".repeat(WARNING_BOX_WIDTH - 2)}│`);
1618
- }
1619
- lines.push(`│ Local versions will be used. To use Silk defaults, remove these${" ".repeat(WARNING_BOX_WIDTH - 69)}│`);
1620
- lines.push(`│ entries from your pnpm-workspace.yaml catalogs section.${" ".repeat(WARNING_BOX_WIDTH - 62)}│`);
1621
- lines.push(`└${border}┘`);
1622
- return lines.join("\n");
1623
- }
1624
- function warnOverrides(overrides) {
1625
- if (overrides.length > 0) console.warn(formatOverrideWarning(overrides));
1626
- }
1627
- function mergeSingleCatalog(catalogName, silkCatalog, localCatalog, overrides) {
1628
- const merged = {
1629
- ...silkCatalog
1630
- };
1631
- if (!localCatalog) return merged;
1632
- for (const [pkg, localVersion] of Object.entries(localCatalog)){
1633
- const silkVersion = silkCatalog[pkg];
1634
- if (void 0 !== silkVersion && silkVersion !== localVersion) overrides.push({
1635
- catalog: catalogName,
1636
- package: pkg,
1637
- silkVersion,
1638
- localVersion
1639
- });
1640
- merged[pkg] = localVersion;
1641
- }
1642
- return merged;
175
+ merged[pkg] = localVersion;
1643
176
  }
1644
- function mergeOverrides(silkOverrides, localOverrides, overrideWarnings) {
1645
- const merged = {
1646
- ...silkOverrides
177
+ return merged;
178
+ }
179
+ function mergeStringArrays(silkArray, localArray) {
180
+ const merged = new Set(silkArray);
181
+ if (localArray) for (const item of localArray)merged.add(item);
182
+ return [
183
+ ...merged
184
+ ].sort((a, b)=>a.localeCompare(b));
185
+ }
186
+ function updateConfig(config) {
187
+ try {
188
+ const warnings = [];
189
+ const existingCatalogs = config.catalogs ?? {};
190
+ const mergedSilk = mergeSingleCatalog("silk", silkCatalogs.silk, existingCatalogs.silk, warnings);
191
+ const mergedSilkPeers = mergeSingleCatalog("silkPeers", silkCatalogs.silkPeers, existingCatalogs.silkPeers, warnings);
192
+ const mergedOverrides = mergeOverrides(silkCatalogs.silkOverrides, config.overrides, warnings);
193
+ const mergedOnlyBuiltDependencies = mergeStringArrays(silkCatalogs.silkOnlyBuiltDependencies, config.onlyBuiltDependencies);
194
+ const mergedPublicHoistPattern = mergeStringArrays(silkCatalogs.silkPublicHoistPattern, config.publicHoistPattern);
195
+ warnOverrides(warnings);
196
+ return {
197
+ ...config,
198
+ catalogs: {
199
+ ...existingCatalogs,
200
+ silk: mergedSilk,
201
+ silkPeers: mergedSilkPeers
202
+ },
203
+ overrides: mergedOverrides,
204
+ onlyBuiltDependencies: mergedOnlyBuiltDependencies,
205
+ publicHoistPattern: mergedPublicHoistPattern
1647
206
  };
1648
- if (!localOverrides) return merged;
1649
- for (const [pkg, localVersion] of Object.entries(localOverrides)){
1650
- const silkVersion = silkOverrides[pkg];
1651
- if (void 0 !== silkVersion && silkVersion !== localVersion) overrideWarnings.push({
1652
- catalog: "overrides",
1653
- package: pkg,
1654
- silkVersion,
1655
- localVersion
1656
- });
1657
- merged[pkg] = localVersion;
1658
- }
1659
- return merged;
207
+ } catch (error) {
208
+ console.warn("[pnpm-plugin-silk] Error merging catalogs, using local config only:", error instanceof Error ? error.message : String(error));
209
+ return config;
1660
210
  }
1661
- function mergeStringArrays(silkArray, localArray) {
1662
- const merged = new Set(silkArray);
1663
- if (localArray) for (const item of localArray)merged.add(item);
1664
- return [
1665
- ...merged
1666
- ].sort((a, b)=>a.localeCompare(b));
1667
- }
1668
- function updateConfig(config) {
1669
- try {
1670
- const warnings = [];
1671
- const existingCatalogs = config.catalogs ?? {};
1672
- const mergedSilk = mergeSingleCatalog("silk", silkCatalogs.silk, existingCatalogs.silk, warnings);
1673
- const mergedSilkPeers = mergeSingleCatalog("silkPeers", silkCatalogs.silkPeers, existingCatalogs.silkPeers, warnings);
1674
- const mergedOverrides = mergeOverrides(silkCatalogs.silkOverrides, config.overrides, warnings);
1675
- const mergedOnlyBuiltDependencies = mergeStringArrays(silkCatalogs.silkOnlyBuiltDependencies, config.onlyBuiltDependencies);
1676
- const mergedPublicHoistPattern = mergeStringArrays(silkCatalogs.silkPublicHoistPattern, config.publicHoistPattern);
1677
- warnOverrides(warnings);
1678
- return {
1679
- ...config,
1680
- catalogs: {
1681
- ...existingCatalogs,
1682
- silk: mergedSilk,
1683
- silkPeers: mergedSilkPeers
1684
- },
1685
- overrides: mergedOverrides,
1686
- onlyBuiltDependencies: mergedOnlyBuiltDependencies,
1687
- publicHoistPattern: mergedPublicHoistPattern
1688
- };
1689
- } catch (error) {
1690
- console.warn("[pnpm-plugin-silk] Error merging catalogs, using local config only:", error instanceof Error ? error.message : String(error));
1691
- return config;
211
+ }
212
+ module.exports = {
213
+ hooks: {
214
+ updateConfig (config) {
215
+ return updateConfig(config);
1692
216
  }
1693
217
  }
1694
- module.exports = {
1695
- hooks: {
1696
- async updateConfig (config) {
1697
- const updatedConfig = updateConfig(config);
1698
- const biomeVersion = silkCatalogs.silk["@biomejs/biome"] ?? silkCatalogs.silkPeers["@biomejs/biome"];
1699
- if (biomeVersion) await syncBiomeSchema(process.cwd(), biomeVersion);
1700
- return updatedConfig;
1701
- }
1702
- }
1703
- };
1704
- })();
218
+ };
1705
219
  for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
1706
220
  Object.defineProperty(exports, '__esModule', {
1707
221
  value: true