@jointhedots/gear 1.1.14 → 1.1.16

package/browser-modules/asap-raw.js

@@ -38,7 +38,7 @@ function flush() {
     flushing = false;
 }
 
-var scope = typeof globalThis !== "undefined" ? globalThis : (typeof self !== "undefined" ? self : window);
+var scope = typeof globalThis !== "undefined" ? globalThis : (typeof self !== "undefined" ? self : globalThis);
 var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
 
 if (typeof BrowserMutationObserver === "function") {

package/browser-modules/process.js

@@ -227,7 +227,7 @@ const process = {
     config,
     uptime,
 }
-window.process = process
+globalThis.process = process
 
 export {
     nextTick,

package/browser-modules/side-effects.js

@@ -4,5 +4,214 @@
 import './process.js'
 import './buffer.js'
 
-// Make Buffer available globally
-globalThis.Buffer = Buffer
+// Add Node.js-specific API to W3C ReadableStream
+{
+   const proto = ReadableStream.prototype
+
+   // Start consuming the stream, emitting 'data'/'end'/'error'/'close' events
+   function _startReading(stream) {
+      if (stream._reading) return
+      stream._reading = true
+      stream._paused = false
+      const reader = stream.getReader()
+      const pump = () => reader.read().then(({ done, value }) => {
+         if (done) {
+            stream._reading = false
+            stream._emit('end')
+            stream._emit('close')
+            return
+         }
+         stream._emit('data', value)
+         if (!stream._paused) return pump()
+         stream._pump = pump
+      }).catch(err => {
+         stream._reading = false
+         stream._emit('error', err)
+      })
+      pump()
+   }
+
+   proto._emit = function (event, ...args) {
+      this._listeners?.[event]?.slice().forEach(fn => fn(...args))
+   }
+
+   proto.on = proto.addListener = function (event, fn) {
+      this._listeners ??= {}
+         ; (this._listeners[event] ??= []).push(fn)
+      if (event === 'data') _startReading(this)
+      return this
+   }
+
+   proto.once = function (event, fn) {
+      const wrapped = (...args) => { this.off(event, wrapped); fn(...args) }
+      return this.on(event, wrapped)
+   }
+
+   proto.off = proto.removeListener = function (event, fn) {
+      const list = this._listeners?.[event]
+      if (list) { const i = list.indexOf(fn); if (i >= 0) list.splice(i, 1) }
+      return this
+   }
+
+   proto.pipe = function (dest) {
+      this.on('data', chunk => dest.write?.(chunk))
+      this.once('end', () => dest.end?.())
+      this.once('error', err => dest.destroy?.(err))
+      return dest
+   }
+
+   proto.pause = function () {
+      this._paused = true
+      return this
+   }
+
+   proto.resume = function () {
+      this._paused = false
+      this._pump?.()
+      return this
+   }
+
+   proto.destroy = function (err) {
+      if (err) this._emit('error', err)
+      this._emit('close')
+      this.cancel(err).catch(() => { })
+      return this
+   }
+
+   proto.unpipe = function (dest) {
+      this._listeners = {}
+      return this
+   }
+}
+
+// Add Node.js-specific API to W3C WritableStream
+{
+   const proto = WritableStream.prototype
+
+   proto._emit = function (event, ...args) {
+      this._listeners?.[event]?.slice().forEach(fn => fn(...args))
+   }
+
+   proto.on = proto.addListener = function (event, fn) {
+      this._listeners ??= {}
+         ; (this._listeners[event] ??= []).push(fn)
+      return this
+   }
+
+   proto.once = function (event, fn) {
+      const wrapped = (...args) => { this.off(event, wrapped); fn(...args) }
+      return this.on(event, wrapped)
+   }
+
+   proto.off = proto.removeListener = function (event, fn) {
+      const list = this._listeners?.[event]
+      if (list) { const i = list.indexOf(fn); if (i >= 0) list.splice(i, 1) }
+      return this
+   }
+
+   proto._getWriter = function () {
+      if (!this._writer) this._writer = this.getWriter()
+      return this._writer
+   }
+
+   proto.write = function (chunk, encoding, callback) {
+      if (typeof encoding === 'function') { callback = encoding; encoding = undefined }
+      const writer = this._getWriter()
+      writer.ready.then(() => writer.write(chunk)).then(
+         () => { this._emit('drain'); callback?.() },
+         err => { this._emit('error', err); callback?.(err) }
+      )
+      return true
+   }
+
+   proto.end = function (chunk, encoding, callback) {
+      if (typeof chunk === 'function') { callback = chunk; chunk = null }
+      else if (typeof encoding === 'function') { callback = encoding; encoding = null }
+      const writer = this._getWriter()
+      const finish = () => writer.close().then(
+         () => { this._emit('finish'); this._emit('close'); callback?.() },
+         err => { this._emit('error', err); callback?.(err) }
+      )
+      if (chunk != null) {
+         writer.ready.then(() => writer.write(chunk)).then(finish, finish)
+      } else {
+         finish()
+      }
+      return this
+   }
+
+   proto.destroy = function (err) {
+      const writer = this._getWriter()
+      if (err) {
+         writer.abort(err).catch(() => { })
+         this._emit('error', err)
+      } else {
+         writer.close().catch(() => { })
+      }
+      this._emit('close')
+      return this
+   }
+
+   proto.cork = function () { this._corked = (this._corked || 0) + 1 }
+   proto.uncork = function () { if (this._corked > 0) this._corked-- }
+
+   proto.setDefaultEncoding = function (encoding) {
+      this._defaultEncoding = encoding
+      return this
+   }
+}
+
+// Add Node.js-specific API to W3C TransformStream
+{
+   const proto = TransformStream.prototype
+
+   proto._emit = function (event, ...args) {
+      this._listeners?.[event]?.slice().forEach(fn => fn(...args))
+   }
+
+   proto.on = proto.addListener = function (event, fn) {
+      this._listeners ??= {}
+         ; (this._listeners[event] ??= []).push(fn)
+      if (event === 'data') this.readable.on('data', chunk => this._emit('data', chunk))
+      return this
+   }
+
+   proto.once = function (event, fn) {
+      const wrapped = (...args) => { this.off(event, wrapped); fn(...args) }
+      return this.on(event, wrapped)
+   }
+
+   proto.off = proto.removeListener = function (event, fn) {
+      const list = this._listeners?.[event]
+      if (list) { const i = list.indexOf(fn); if (i >= 0) list.splice(i, 1) }
+      return this
+   }
+
+   proto.write = function (chunk, encoding, callback) {
+      return this.writable.write(chunk, encoding, callback)
+   }
+
+   proto.end = function (chunk, encoding, callback) {
+      return this.writable.end(chunk, encoding, callback)
+   }
+
+   proto.pipe = function (dest) {
+      return this.readable.pipe(dest)
+   }
+
+   proto.pause = function () {
+      this.readable.pause()
+      return this
+   }
+
+   proto.resume = function () {
+      this.readable.resume()
+      return this
+   }
+
+   proto.destroy = function (err) {
+      this.readable.destroy(err)
+      this.writable.destroy(err)
+      return this
+   }
+}

package/esm/builder/helpers/emit-esmodules.js

@@ -21,7 +21,7 @@ function getEsbuildLogLevel(mode) {
             return "silent";
     }
 }
-export async function create_esbuild_context(task, devmode) {
+async function create_esbuild_context(task, devmode, onReady) {
     const ws = task.target.workspace;
     // Define modules mapping - using @jspm/core polyfills (same as Vite)
     const jspmPolyfills = Path.resolve(PackageRootDir, "node_modules/@jspm/core/nodelibs/browser");
@@ -111,7 +111,7 @@ export async function create_esbuild_context(task, devmode) {
             ESModuleResolverPlugin(modules_mapping, tsconfig),
             ...task.plugins,
             StyleSheetPlugin(task),
-            StoragePlugin(task),
+            StoragePlugin(task, onReady),
         ],
         loader: {
             '.jpg': 'file',
@@ -255,7 +255,7 @@ function hasTailwindConfig(workspacePath) {
     catch { }
     return false;
 }
-export function StoragePlugin(task) {
+export function StoragePlugin(task, onReady) {
     return {
         name: "dipatch-files",
         setup: (build) => {
@@ -290,7 +290,11 @@ export function StoragePlugin(task) {
                     task.target.store();
                     const storeTime = (Date.now() - storeStart) / 1000;
                     const buildTime = (Date.now() - buildStartTime) / 1000;
-                    task.log.info(`Build ES modules in ${result.outputFiles.length} file(s) (compile: ${buildTime.toFixed(2)}s, store: ${storeTime.toFixed(2)}s)`);
+                    task.log.info(`Store ES graph in ${result.outputFiles.length} file(s) (compile: ${buildTime.toFixed(2)}s, store: ${storeTime.toFixed(2)}s)`);
+                }
+                if (onReady) {
+                    onReady();
+                    onReady = null;
                 }
                 return null;
             });
@@ -602,11 +606,14 @@ export class ESModulesTask extends BuildTask {
             await prev_ctx.dispose();
         }
         const { target } = this;
-        this.context = await create_esbuild_context(this, target.devmode);
         if (target.watch) {
-            await this.context.watch();
+            return new Promise(async (resolve, reject) => {
+                this.context = await create_esbuild_context(this, target.devmode, resolve);
+                await this.context.watch();
+            });
         }
         else {
+            this.context = await create_esbuild_context(this, target.devmode);
             await this.context.rebuild();
             await this.context.dispose();
         }

package/esm/builder/helpers/emit-typescript-definition.js

@@ -2,7 +2,8 @@ import Fs from 'fs';
 import Os from 'os';
 import Path from 'path';
 import Ts from 'typescript';
-import { execFileSync } from 'child_process';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { BuildTask } from "./task.js";
 import { BuildTarget } from "../build-target.js";
 import { Library } from "../../model/workspace.js";
@@ -93,7 +94,7 @@ class TypescriptProject {
         this.dtsDir = Fs.mkdtempSync(Path.join(Os.tmpdir(), 'gear-dts-'));
     }
     /** Run tsgo to emit .d.ts files into dtsDir. Returns stderr output. */
-    emitWithTsgo() {
+    async emitWithTsgo() {
         const tsgoPath = Path.resolve('node_modules/.bin/tsgo');
         const args = [
             '-p', Path.join(this.baseDir, 'tsconfig.json'),
@@ -103,17 +104,14 @@ class TypescriptProject {
             '--outDir', this.dtsDir,
         ];
         try {
-            execFileSync(tsgoPath, args, {
+            await promisify(execFile)(tsgoPath, args, {
                 cwd: this.baseDir,
-                stdio: ['pipe', 'pipe', 'pipe'],
                 timeout: 120_000,
                 shell: true,
             });
-            return '';
         }
         catch (e) {
             // tsgo may exit non-zero on type errors but still emit .d.ts files
-            return e.stderr?.toString() || e.message || '';
         }
     }
     /** Recursively collect all .d.ts files emitted by tsgo */
@@ -144,30 +142,11 @@ export function createTypescriptProject(baseDir, tsconfig, outDir) {
     return new TypescriptProject(baseDir, tsconfig, outDir);
 }
 export function generateTypescriptDefinition(options) {
-    const project = options.project;
+    const { project, prefix } = options;
     const baseDir = project.baseDir;
-    const dtsDir = project.dtsDir;
-    function isExcludedPath(fileName) {
-        return fileName.includes('/node_modules/') || fileName.includes('\\node_modules\\');
-    }
-    // Compute baseUrl prefix to strip from module paths
     const normalizedBaseDir = normalizeFileName(Path.resolve(baseDir)) + "/";
-    const normalizedDtsDir = normalizeFileName(Path.resolve(dtsDir)) + "/";
-    let baseUrlPrefix = '';
-    if (project.compilerOptions.baseUrl) {
-        const absoluteBaseUrl = Path.resolve(baseDir, project.compilerOptions.baseUrl);
-        const normalizedBaseUrl = normalizeFileName(absoluteBaseUrl);
-        baseUrlPrefix = normalizedBaseUrl.slice(normalizedBaseDir.length);
-        if (baseUrlPrefix && !baseUrlPrefix.endsWith('/')) {
-            baseUrlPrefix += '/';
-        }
-    }
-    function stripBaseUrlPrefix(modulePath) {
-        if (baseUrlPrefix && modulePath.startsWith(baseUrlPrefix)) {
-            return modulePath.slice(baseUrlPrefix.length);
-        }
-        return modulePath;
-    }
+    const normalizedDtsDir = normalizeFileName(Path.resolve(project.dtsDir)) + "/";
+    const resolveCache = new Map();
     const outputParts = [];
     if (options.externs) {
         options.externs.forEach(function (path) {
@@ -179,8 +158,7 @@ export function generateTypescriptDefinition(options) {
             outputParts.push(`/// <reference types="${type}" />` + eol);
         });
     }
-    // Map source-relative paths to internal: module IDs for ALL emitted files
-    const internalsMap = {};
+    // Process each emitted .d.ts file as internal: module
     const dtsFiles = project.getEmittedDtsFiles();
     for (const dtsPath of dtsFiles) {
         const normalizedDts = normalizeFileName(Path.resolve(dtsPath));
@@ -188,83 +166,55 @@ export function generateTypescriptDefinition(options) {
             continue;
         const relativeDts = normalizedDts.slice(normalizedDtsDir.length);
         const relativeSource = relativeDts.replace(/\.d\.ts$/, '');
-        const strippedSource = stripBaseUrlPrefix(relativeSource);
-        const moduleId = `${options.prefix}:${strippedSource}`;
-        internalsMap[relativeSource] = moduleId;
-        internalsMap[strippedSource] = moduleId;
-        if (strippedSource.endsWith('/index')) {
-            internalsMap[strippedSource.slice(0, -6)] = moduleId;
-        }
+        const data = Fs.readFileSync(dtsPath, 'utf-8');
+        const declFile = Ts.createSourceFile(dtsPath, data, Ts.ScriptTarget.Latest, true);
+        writeDeclaration(declFile, relativeSource);
     }
-    // Build public export map: maps export entry ID to internal module ID
-    const publicReexports = [];
+    // Emit public re-export modules
     if (options.exports) {
         for (const entry of Object.values(options.exports)) {
-            const fileName = entry.source;
-            if (isExcludedPath(fileName))
-                continue;
-            const normalizedSource = normalizeFileName(Path.resolve(fileName));
-            if (!normalizedSource.startsWith(normalizedBaseDir))
-                continue;
-            const shortName = normalizedSource.slice(normalizedBaseDir.length);
-            const shortNameNoExt = shortName.replace(/\.(ts|tsx|js|jsx)$/, '');
-            const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-            const internalId = internalsMap[shortNameNoExt] ||
-                internalsMap[strippedShortNameNoExt] ||
-                internalsMap[shortName];
+            const internalId = resolveInternalModuleImport(entry.source);
             if (internalId) {
-                publicReexports.push({ id: entry.id, internalId });
+                outputParts.push(`declare module '${entry.id}' {${eol}`);
+                outputParts.push(`${indent}export * from '${internalId}';${eol}`);
+                outputParts.push(`}${eol}${eol}`);
             }
         }
     }
-    // Unified module ID normalization
-    function normalizeModuleId(moduleId) {
-        moduleId = moduleId.replace(/\.(d\.ts|ts|tsx|js|jsx)$/, '');
-        moduleId = stripBaseUrlPrefix(moduleId);
-        const remapped = internalsMap[moduleId] ||
-            internalsMap[moduleId + "/index"] ||
-            internalsMap[moduleId + "/index.ts"];
-        return remapped || moduleId;
-    }
-    function isExternalModule(moduleId) {
-        return !internalsMap[moduleId];
-    }
-    // Process each emitted .d.ts file as internal: module
-    for (const dtsPath of dtsFiles) {
-        const normalizedDts = normalizeFileName(Path.resolve(dtsPath));
-        if (!normalizedDts.startsWith(normalizedDtsDir))
-            continue;
-        const relativeDts = normalizedDts.slice(normalizedDtsDir.length);
-        const relativeSource = relativeDts.replace(/\.d\.ts$/, '');
-        const data = Fs.readFileSync(dtsPath, 'utf-8');
-        const declFile = Ts.createSourceFile(dtsPath, data, Ts.ScriptTarget.Latest, true);
-        writeDeclaration(declFile, relativeSource);
-    }
-    // Emit public re-export modules
-    for (const { id, internalId } of publicReexports) {
-        outputParts.push(`declare module '${id}' {${eol}`);
-        outputParts.push(`${indent}export * from '${internalId}';${eol}`);
-        outputParts.push(`}${eol}${eol}`);
+    function resolveInternalModuleImport(moduleId, importDir = "") {
+        if (moduleId.charAt(0) === '.') {
+            return prefix + normalizeFileName(Path.join(importDir, moduleId));
+        }
+        if (resolveCache.has(moduleId))
+            return resolveCache.get(moduleId);
+        const containingFile = Path.resolve(baseDir, importDir, '__resolve.ts');
+        const result = Ts.resolveModuleName(moduleId, containingFile, project.compilerOptions, Ts.sys);
+        if (result.resolvedModule && !result.resolvedModule.isExternalLibraryImport) {
+            const resolved = normalizeFileName(result.resolvedModule.resolvedFileName);
+            if (resolved.startsWith(normalizedBaseDir)) {
+                const value = prefix + resolved.slice(normalizedBaseDir.length).replace(/\.(d\.ts|tsx?|jsx?)$/, '');
+                resolveCache.set(moduleId, value);
+                return value;
+            }
+        }
+        // Check if moduleId is already an internal path relative to baseDir
+        const absolute = normalizeFileName(Path.resolve(baseDir, importDir, moduleId));
+        if (absolute.startsWith(normalizedBaseDir)) {
+            const value = prefix + absolute.slice(normalizedBaseDir.length);
+            resolveCache.set(moduleId, value);
+            return value;
+        }
+        resolveCache.set(moduleId, null);
+        return null;
     }
     function writeDeclaration(declarationFile, rawSourceModuleId) {
-        const moduleDeclId = normalizeModuleId(rawSourceModuleId);
+        const moduleDeclId = resolveInternalModuleImport(rawSourceModuleId);
+        const moduleDir = Path.dirname(rawSourceModuleId);
         outputParts.push(`declare module '${moduleDeclId}' {${eol}${indent}`);
-        function resolveModuleImport(moduleId) {
-            let resolved;
-            if (moduleId.charAt(0) === '.') {
-                resolved = normalizeFileName(Path.join(Path.dirname(rawSourceModuleId), moduleId));
-            }
-            else {
-                resolved = moduleId;
-                if (isExternalModule(resolved))
-                    return resolved;
-            }
-            return normalizeModuleId(resolved);
-        }
         const content = processTree(declarationFile, function (node) {
             if (isNodeKindExternalModuleReference(node)) {
                 const expression = node.expression;
-                const resolved = resolveModuleImport(expression.text);
+                const resolved = resolveInternalModuleImport(expression.text, moduleDir) ?? expression.text;
                 return ` require('${resolved}')`;
             }
             else if (isNodeKindImportDeclaration(node) && !node.importClause) {
@@ -275,8 +225,8 @@ export function generateTypescriptDefinition(options) {
             }
             else if (isNodeKindStringLiteral(node) && node.parent &&
                 (isNodeKindExportDeclaration(node.parent) || isNodeKindImportDeclaration(node.parent) || isNodeKindImportType(node.parent?.parent))) {
-                const resolved = resolveModuleImport(node.text);
-                if (resolved) {
+                const resolved = resolveInternalModuleImport(node.text, moduleDir);
+                if (resolved != null) {
                     return ` '${resolved}'`;
                 }
             }
@@ -304,13 +254,10 @@ export class TypescriptDefinitionTask extends BuildTask {
             const configText = file.read.text(Path.join(lib.path, "./tsconfig.json"))
                 || file.read.text("./tsconfig.json");
             const project = createTypescriptProject(lib.path, configText, storage.getBaseDirFS());
-            const stderr = project.emitWithTsgo();
-            if (stderr) {
-                this.log.warn(stderr);
-            }
+            await project.emitWithTsgo();
             const { dts } = generateTypescriptDefinition({
                 project,
-                prefix: lib.name,
+                prefix: lib.name + ":",
                 exclude: ["node_modules/**/*"],
                 exports: create_export_map(lib, lib.bundle),
             });

package/esm/model/helpers/discover-workspace.js

@@ -7,6 +7,7 @@ import { create_bundle_manifest } from "./create-manifests.js";
 import { Bundle, Library, Workspace } from "../workspace.js";
 import { file, make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
 import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
+import { read_lockfile } from "./lockfile.js";
 const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
@@ -252,7 +253,7 @@ function show_constants(ws) {
     }
 }
 export async function discover_workspace(ws) {
-    let package_lock = null;
+    let lockfile = null;
     for (let path = ws.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
         if (package_json) {
@@ -267,30 +268,20 @@ export async function discover_workspace(ws) {
                 };
             }
         }
-        const package_lock_path = path + "/package-lock.json";
-        if (!package_lock && Fs.existsSync(package_lock_path)) {
-            package_lock = await readJsonFile(package_lock_path);
+        if (!lockfile) {
+            lockfile = await read_lockfile(path);
         }
         const next_path = make_normalized_dirname(path);
         if (next_path === path)
             break;
         path = next_path;
     }
-    if (!package_lock) {
-        throw new Error(`Package lock not found for '${ws.name}'`);
-    }
-    for (const location in package_lock.packages) {
-        let pkg = package_lock.packages[location];
-        if (location.startsWith("node_modules/")) {
-            if (pkg.link) {
-                pkg = package_lock.packages[pkg.resolved];
-            }
-            const name = location.replace(/^.*node_modules\//, "");
-            ws.resolved_versions[name] = pkg.version;
-        }
+    if (!lockfile) {
+        throw new Error(`Lock file not found for '${ws.name}'`);
     }
+    ws.resolved_versions = lockfile.resolved_versions;
     await discover_workspace_libraries(ws);
-    for (const location in package_lock.packages) {
+    for (const location of lockfile.installed_locations) {
         await discover_library(ws, location, true);
     }
     for (const bun of ws.bundles) {

package/esm/model/helpers/lockfile.js

@@ -0,0 +1,108 @@
+import Fs from "node:fs";
+import Fsp from "node:fs/promises";
+import YAML from "yaml";
+import { readJsonFile } from "../storage.js";
+export async function read_lockfile(dir) {
+    const npm_path = dir + "/package-lock.json";
+    if (Fs.existsSync(npm_path)) {
+        return parse_npm_lockfile(await readJsonFile(npm_path));
+    }
+    const pnpm_path = dir + "/pnpm-lock.yaml";
+    if (Fs.existsSync(pnpm_path)) {
+        return parse_pnpm_lockfile(YAML.parse(await Fsp.readFile(pnpm_path, "utf-8")));
+    }
+    const yarn_path = dir + "/yarn.lock";
+    if (Fs.existsSync(yarn_path)) {
+        return parse_yarn_lockfile(await Fsp.readFile(yarn_path, "utf-8"));
+    }
+    return null;
+}
+function parse_npm_lockfile(lock) {
+    const resolved_versions = {};
+    const installed_locations = [];
+    for (const location in lock.packages) {
+        if (!location)
+            continue;
+        installed_locations.push(location);
+        if (location.startsWith("node_modules/")) {
+            let pkg = lock.packages[location];
+            if (pkg.link) {
+                pkg = lock.packages[pkg.resolved];
+            }
+            const name = location.replace(/^.*node_modules\//, "");
+            if (pkg?.version) {
+                resolved_versions[name] = pkg.version;
+            }
+        }
+    }
+    return { resolved_versions, installed_locations };
+}
+function parse_pnpm_lockfile(lock) {
+    const resolved_versions = {};
+    const locations = new Set();
+    if (lock.packages) {
+        for (const key in lock.packages) {
+            const clean = key.startsWith("/") ? key.slice(1) : key;
+            const atIdx = clean.lastIndexOf("@");
+            if (atIdx > 0) {
+                const name = clean.slice(0, atIdx);
+                const version = clean.slice(atIdx + 1).split("(")[0];
+                if (name && version) {
+                    resolved_versions[name] = version;
+                    locations.add("node_modules/" + name);
+                }
+            }
+        }
+    }
+    if (lock.importers) {
+        for (const key in lock.importers) {
+            if (key !== ".")
+                locations.add(key);
+        }
+    }
+    return { resolved_versions, installed_locations: [...locations] };
+}
+function parse_yarn_lockfile(text) {
+    const resolved_versions = {};
+    const locations = new Set();
+    if (text.includes("__metadata:")) {
+        const lock = YAML.parse(text);
+        for (const key in lock) {
+            if (key === "__metadata")
+                continue;
+            if (lock[key]?.version) {
+                const name = extract_package_name(key.split(",")[0].trim());
+                if (name) {
+                    resolved_versions[name] = lock[key].version;
+                    locations.add("node_modules/" + name);
+                }
+            }
+        }
+    }
+    else {
+        parse_yarn_classic(text, resolved_versions, locations);
+    }
+    return { resolved_versions, installed_locations: [...locations] };
+}
+function extract_package_name(entry) {
+    entry = entry.replace(/^"|"$/g, "");
+    // @scope/name@version or name@version
+    const at = entry.startsWith("@") ? entry.indexOf("@", 1) : entry.indexOf("@");
+    return at > 0 ? entry.slice(0, at) : null;
+}
+function parse_yarn_classic(text, resolved_versions, locations) {
+    let current_name = null;
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!line.startsWith(" ") && !line.startsWith("#") && trimmed.endsWith(":")) {
+            current_name = extract_package_name(trimmed.slice(0, -1).split(",")[0].trim());
+        }
+        else if (current_name && trimmed.startsWith("version ")) {
+            const version = trimmed.slice(8).replace(/^"|"$/g, "");
+            resolved_versions[current_name] = version;
+            locations.add("node_modules/" + current_name);
+            current_name = null;
+        }
+    }
+}
+//# sourceMappingURL=lockfile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.14",
+   "version": "1.1.16",
    "type": "module",
    "bin": {
       "jointhedots-gear": "esm/cli.js"