@veryfront/ext-parser-babel 0.1.1238 → 0.1.1240

package/README.md

@@ -18,10 +18,12 @@ export default defineConfig({
 
 ## Provided contract
 
-`CodeParser` — exposes:
+`CodeParser` exposes:
 
-- `parse(source, options)` / `traverse(ast, visitor)` / `generate(ast, options)` — generic AST pipeline for callers that want to build custom transforms.
-- `injectJsxNodePositions(source, options)` — the Studio Navigator helper that stamps `data-node-*` attributes onto JSX elements at compile time.
+- `parse(options)` / `traverse(ast, visitor)` / `generate(ast, options)`: generic AST pipeline for callers that want to build custom transforms.
+- `hasFunctionDirective(options)`: parser-owned function directive detection with Babel's syntax semantics.
+- `findStaticCommonJsImports(options)`: parser-owned static CommonJS discovery that respects lexical and TypeScript bindings.
+- `injectJsxNodePositions(source, options)`: the Studio Navigator helper that stamps `data-node-*` attributes onto JSX elements at compile time.
 
 Core's `src/transforms/plugins/babel-node-positions.ts` is a thin shim that resolves this contract at call time. When the extension is not installed and the shim is invoked, Veryfront throws an install-suggestion error directing the user to add `@veryfront/ext-parser-babel`.
 

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,11 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+export { setInterval, setTimeout } from "@deno/shim-timers";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno" | "crypto" | "setInterval" | "setTimeout"> & {
+    Deno: typeof Deno;
+    crypto: import("@deno/shim-crypto").Crypto;
+    setInterval: any;
+    setTimeout: any;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErvB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQ5D,eAAO,MAAM,aAAa;;;;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,90 @@
+const dntNativeDeno = globalThis.Deno;
+// Prefer the host runtime's own Deno. The `@deno/shim-deno` fallback exists
+// for Node and Bun; under Deno it shadows working native APIs with node:net
+// reimplementations that throw (e.g. Deno.listen reads `server._handle.fd`,
+// which is null on Deno's node compatibility layer).
+//
+// It loads lazily so Deno never resolves it at all. The esm transform
+// rewrites the bare specifier to an absolute file:// bundle, and Deno
+// refuses to prepare that graph node when node_modules is unmanaged, which
+// is what `deno install -g` produces (`nodeModulesDir: "manual"`). A static
+// import therefore failed every request with "Loading unprepared module"
+// naming a bundle that was present on disk, on the one runtime that never
+// reads the value.
+export const Deno = typeof dntNativeDeno?.version?.deno === "string"
+    ? dntNativeDeno
+    : (await import("@deno/shim-deno")).Deno;
+const dntNativeCrypto = globalThis.crypto;
+// Web Crypto is a global on every runtime the framework supports (Deno,
+// Node 19+, Bun), so `@deno/shim-crypto` is a fallback for runtimes that no
+// longer exist in practice. It loads lazily for the same reason the Deno
+// shim does: the esm transform rewrites the bare specifier to an absolute
+// file:// bundle, and Deno cannot prepare that graph node when node_modules
+// is unmanaged.
+export const crypto = dntNativeCrypto !== undefined
+    ? dntNativeCrypto
+    : (await import("@deno/shim-crypto")).crypto;
+import { setInterval, setTimeout } from "@deno/shim-timers";
+export { setInterval, setTimeout } from "@deno/shim-timers";
+const dntGlobals = {
+    Deno,
+    crypto,
+    setInterval,
+    setTimeout,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/index.d.ts

@@ -1,25 +1,11 @@
-/**
- * ext-parser-babel — CodeParser implementation backed by @babel/parser,
- * @babel/traverse, @babel/generator, @babel/types.
- *
- * Provides the `CodeParser` contract:
- *  - `parse/traverse/generate` — generic AST pipeline for callers that
- *    want to build custom transforms.
- *  - `injectJsxNodePositions(source, options)` — the Studio Navigator
- *    helper that stamps `data-node-*` attributes onto JSX elements.
- *
- * Core's `src/transforms/plugins/babel-node-positions.ts` is a shim that
- * resolves this contract at call time.
- *
- * @module extensions/ext-parser-babel
- */
 import type { ExtensionFactory } from "veryfront/extensions";
-import type { ASTNode, CodeParser, FunctionDirectiveOptions, GenerateOptions, GenerateResult, InjectJsxNodePositionsOptions, TraverseVisitor } from "veryfront/extensions/parser";
+import type { ASTNode, CodeParser, FunctionDirectiveOptions, GenerateOptions, GenerateResult, InjectJsxNodePositionsOptions, ParseOptions, TraverseVisitor } from "veryfront/extensions/parser";
 import { BabelParseOnlyParser } from "./parser-only.js";
 declare class BabelCodeParser extends BabelParseOnlyParser implements CodeParser {
     traverse(ast: ASTNode, visitor: TraverseVisitor): void;
     generate(ast: ASTNode, options?: GenerateOptions): Promise<GenerateResult>;
     hasFunctionDirective(options: FunctionDirectiveOptions): Promise<boolean>;
+    findStaticCommonJsImports(options: ParseOptions): Promise<readonly string[]>;
     injectJsxNodePositions(source: string, options: InjectJsxNodePositionsOptions): string;
 }
 declare const extBabel: ExtensionFactory;

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,cAAc,EACd,6BAA6B,EAC7B,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAwDxD,cAAM,eAAgB,SAAQ,oBAAqB,YAAW,UAAU;IACtE,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI;IAItD,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAWpE,oBAAoB,CACxB,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,OAAO,CAAC;IAcnB,sBAAsB,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,6BAA6B,GACrC,MAAM;CAGV;AAED,QAAA,MAAM,QAAQ,EAAE,gBAiBf,CAAC;AAEF,eAAe,QAAQ,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,cAAc,EACd,6BAA6B,EAC7B,YAAY,EACZ,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AA4axD,cAAM,eAAgB,SAAQ,oBAAqB,YAAW,UAAU;IACtE,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI;IAItD,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAWpE,oBAAoB,CACxB,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,OAAO,CAAC;IAcb,yBAAyB,CAC7B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;IAuB7B,sBAAsB,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,6BAA6B,GACrC,MAAM;CAGV;AAED,QAAA,MAAM,QAAQ,EAAE,gBAiBf,CAAC;AAEF,eAAe,QAAQ,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/esm/index.js

@@ -1,11 +1,14 @@
 /**
- * ext-parser-babel — CodeParser implementation backed by @babel/parser,
+ * ext-parser-babel: CodeParser implementation backed by @babel/parser,
  * @babel/traverse, @babel/generator, @babel/types.
  *
  * Provides the `CodeParser` contract:
- *  - `parse/traverse/generate` — generic AST pipeline for callers that
+ *  - `parse/traverse/generate`: generic AST pipeline for callers that
  *    want to build custom transforms.
- *  - `injectJsxNodePositions(source, options)` — the Studio Navigator
+ *  - `hasFunctionDirective(options)`: parser-owned directive detection.
+ *  - `findStaticCommonJsImports(options)`: static CommonJS discovery with
+ *    Babel lexical and TypeScript binding semantics.
+ *  - `injectJsxNodePositions(source, options)`: the Studio Navigator
  *    helper that stamps `data-node-*` attributes onto JSX elements.
  *
  * Core's `src/transforms/plugins/babel-node-positions.ts` is a shim that
@@ -13,8 +16,10 @@
  *
  * @module extensions/ext-parser-babel
  */
+import * as dntShim from "./_dnt.shims.js";
 import * as traverseModule from "@babel/traverse";
 import * as generateModule from "@babel/generator";
+import { BUNDLE_ERROR } from "veryfront/errors";
 import { injectNodePositions } from "./inject-node-positions.js";
 import { BabelParseOnlyParser } from "./parser-only.js";
 function resolveDefaultExport(mod) {
@@ -28,6 +33,88 @@ function resolveDefaultExport(mod) {
 }
 const traverse = resolveDefaultExport(traverseModule);
 const generate = resolveDefaultExport(generateModule);
+const ReflectApply = Reflect.apply;
+const ReflectOwnKeys = Reflect.ownKeys;
+const ArrayIsArray = Array.isArray;
+const ArrayPush = Array.prototype.push;
+const ArraySome = Array.prototype.some;
+const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const MAX_STATIC_STRING_DEPTH = 16;
+const MAX_STATIC_STRING_PARTS = 32;
+const MAX_STATIC_STRING_LENGTH = 2_048;
+function arrayPush(array, value) {
+    return ReflectApply(ArrayPush, array, [value]);
+}
+function arraySome(array, predicate) {
+    return ReflectApply(ArraySome, array, [predicate]);
+}
+function getOwnPropertyDescriptor(owner, key) {
+    return ReflectApply(ObjectGetOwnPropertyDescriptor, Object, [owner, key]);
+}
+function capturePrimitiveMethods(owner) {
+    const keys = ReflectApply(ReflectOwnKeys, Reflect, [owner]);
+    const entries = [];
+    for (let index = 0; index < keys.length; index++) {
+        const key = keys[index];
+        const descriptor = getOwnPropertyDescriptor(owner, key);
+        if (typeof descriptor?.value !== "function")
+            continue;
+        arrayPush(entries, { key, value: descriptor.value });
+    }
+    return { owner, entries };
+}
+const COMMON_JS_ANALYSIS_PRIMITIVES = [
+    capturePrimitiveMethods(Array),
+    capturePrimitiveMethods(Array.prototype),
+    capturePrimitiveMethods(Function.prototype),
+    capturePrimitiveMethods(Map.prototype),
+    capturePrimitiveMethods(Object),
+    capturePrimitiveMethods(Object.prototype),
+    capturePrimitiveMethods(RegExp.prototype),
+    capturePrimitiveMethods(Set.prototype),
+    capturePrimitiveMethods(String.prototype),
+    capturePrimitiveMethods(WeakMap.prototype),
+    capturePrimitiveMethods(WeakSet.prototype),
+];
+const COMMON_JS_ANALYSIS_GLOBALS = [
+    { key: "Array", value: Array },
+    { key: "Function", value: Function },
+    { key: "Map", value: Map },
+    { key: "Object", value: Object },
+    { key: "Promise", value: Promise },
+    { key: "RegExp", value: RegExp },
+    { key: "Set", value: Set },
+    { key: "String", value: String },
+    { key: "WeakMap", value: WeakMap },
+    { key: "WeakSet", value: WeakSet },
+];
+function assertCommonJsAnalysisPrimitives() {
+    let changed = false;
+    for (let index = 0; index < COMMON_JS_ANALYSIS_GLOBALS.length; index++) {
+        const snapshot = COMMON_JS_ANALYSIS_GLOBALS[index];
+        if (getOwnPropertyDescriptor(dntShim.dntGlobalThis, snapshot.key)?.value !== snapshot.value) {
+            changed = true;
+            break;
+        }
+    }
+    for (let ownerIndex = 0; !changed && ownerIndex < COMMON_JS_ANALYSIS_PRIMITIVES.length; ownerIndex++) {
+        const snapshot = COMMON_JS_ANALYSIS_PRIMITIVES[ownerIndex];
+        for (let entryIndex = 0; entryIndex < snapshot.entries.length; entryIndex++) {
+            const entry = snapshot.entries[entryIndex];
+            if (getOwnPropertyDescriptor(snapshot.owner, entry.key)?.value !== entry.value) {
+                changed = true;
+                break;
+            }
+        }
+    }
+    if (changed) {
+        throw BUNDLE_ERROR.create({
+            message: "CommonJS analysis integrity check failed",
+            detail: "Required runtime primitives changed after parser initialization",
+            context: { capability: "findStaticCommonJsImports" },
+        });
+    }
+}
 const FUNCTION_NODE_TYPES = [
     "ArrowFunctionExpression",
     "ClassMethod",
@@ -37,15 +124,238 @@ const FUNCTION_NODE_TYPES = [
     "ObjectMethod",
 ];
 function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    return typeof value === "object" && value !== null && !ArrayIsArray(value);
 }
 function functionHasDirective(node, directive) {
     const body = node.body;
     if (!isRecord(body) || body.type !== "BlockStatement" ||
-        !Array.isArray(body.directives)) {
+        !ArrayIsArray(body.directives)) {
+        return false;
+    }
+    return arraySome(body.directives, (entry) => isRecord(entry) && isRecord(entry.value) && entry.value.value === directive);
+}
+function astNode(value) {
+    return isRecord(value) && typeof value.type === "string" ? value : undefined;
+}
+function unwrapErasedExpression(node) {
+    while (node?.type === "ParenthesizedExpression" || node?.type === "TSAsExpression" ||
+        node?.type === "TSInstantiationExpression" || node?.type === "TSNonNullExpression" ||
+        node?.type === "TSSatisfiesExpression" || node?.type === "TSTypeAssertion") {
+        node = astNode(node.expression);
+    }
+    return node;
+}
+function staticStringValue(node, depth = 0) {
+    if (depth > MAX_STATIC_STRING_DEPTH)
+        return undefined;
+    node = unwrapErasedExpression(node);
+    if (node?.type === "StringLiteral" && typeof node.value === "string") {
+        return node.value.length <= MAX_STATIC_STRING_LENGTH ? node.value : undefined;
+    }
+    if (node?.type === "BinaryExpression" && node.operator === "+") {
+        const left = staticStringValue(astNode(node.left), depth + 1);
+        const right = staticStringValue(astNode(node.right), depth + 1);
+        if (left === undefined || right === undefined)
+            return undefined;
+        return left.length + right.length <= MAX_STATIC_STRING_LENGTH ? left + right : undefined;
+    }
+    if (node?.type !== "TemplateLiteral" || !ArrayIsArray(node.expressions) ||
+        !ArrayIsArray(node.quasis) || node.quasis.length !== node.expressions.length + 1 ||
+        node.quasis.length > MAX_STATIC_STRING_PARTS) {
+        return undefined;
+    }
+    let value = "";
+    for (let index = 0; index < node.quasis.length; index++) {
+        const quasi = astNode(node.quasis[index]);
+        if (!isRecord(quasi?.value) || typeof quasi.value.cooked !== "string")
+            return undefined;
+        value += quasi.value.cooked;
+        if (value.length > MAX_STATIC_STRING_LENGTH)
+            return undefined;
+        if (index >= node.expressions.length)
+            continue;
+        const expression = staticStringValue(astNode(node.expressions[index]), depth + 1);
+        if (expression === undefined || value.length + expression.length > MAX_STATIC_STRING_LENGTH) {
+            return undefined;
+        }
+        value += expression;
+    }
+    return value;
+}
+function memberPropertyName(member) {
+    const property = unwrapErasedExpression(astNode(member.property));
+    return member.computed === true
+        ? staticStringValue(property)
+        : property?.type === "Identifier" && typeof property.name === "string"
+            ? property.name
+            : undefined;
+}
+function commonJsRequireBinding(callee) {
+    callee = unwrapErasedExpression(callee);
+    if (callee?.type === "Identifier" && callee.name === "require")
+        return "require";
+    if (callee?.type === "SequenceExpression") {
+        if (!ArrayIsArray(callee.expressions) || callee.expressions.length === 0)
+            return undefined;
+        return commonJsRequireBinding(astNode(callee.expressions[callee.expressions.length - 1]));
+    }
+    return undefined;
+}
+function commonJsModuleObjectBinding(value) {
+    value = unwrapErasedExpression(value);
+    if (value?.type === "Identifier" && value.name === "module")
+        return "module";
+    if (value?.type === "SequenceExpression") {
+        if (!ArrayIsArray(value.expressions) || value.expressions.length === 0)
+            return undefined;
+        return commonJsModuleObjectBinding(astNode(value.expressions[value.expressions.length - 1]));
+    }
+    if (value?.type !== "MemberExpression" && value?.type !== "OptionalMemberExpression") {
+        return undefined;
+    }
+    return memberPropertyName(value) === "parent"
+        ? commonJsModuleObjectBinding(astNode(value.object))
+        : undefined;
+}
+function commonJsRequireMainBinding(value) {
+    value = unwrapErasedExpression(value);
+    if (value?.type !== "MemberExpression" && value?.type !== "OptionalMemberExpression") {
+        return undefined;
+    }
+    return memberPropertyName(value) === "main"
+        ? commonJsRequireBinding(astNode(value.object))
+        : undefined;
+}
+function commonJsCallableBinding(callee) {
+    callee = unwrapErasedExpression(callee);
+    const requireBinding = commonJsRequireBinding(callee);
+    if (requireBinding !== undefined)
+        return requireBinding;
+    if (callee?.type === "SequenceExpression") {
+        if (!ArrayIsArray(callee.expressions) || callee.expressions.length === 0)
+            return undefined;
+        return commonJsCallableBinding(astNode(callee.expressions[callee.expressions.length - 1]));
+    }
+    if (callee?.type !== "MemberExpression" && callee?.type !== "OptionalMemberExpression") {
+        return undefined;
+    }
+    const object = unwrapErasedExpression(astNode(callee.object));
+    const propertyName = memberPropertyName(callee);
+    if (propertyName === "resolve") {
+        return commonJsRequireBinding(object);
+    }
+    if (propertyName !== "require")
+        return undefined;
+    return commonJsModuleObjectBinding(object) ?? commonJsRequireMainBinding(object);
+}
+function callArguments(call) {
+    return ArrayIsArray(call.arguments) ? call.arguments : undefined;
+}
+function commonJsCallTarget(call) {
+    const args = callArguments(call);
+    const callee = unwrapErasedExpression(astNode(call.callee));
+    if (callee?.type === "CallExpression" || callee?.type === "OptionalCallExpression") {
+        const boundCallee = unwrapErasedExpression(astNode(callee.callee));
+        if (boundCallee?.type === "MemberExpression" ||
+            boundCallee?.type === "OptionalMemberExpression") {
+            if (memberPropertyName(boundCallee) === "bind") {
+                const binding = commonJsCallableBinding(astNode(boundCallee.object));
+                const boundArgs = callArguments(callee);
+                const specifier = boundArgs !== undefined && boundArgs.length >= 2
+                    ? astNode(boundArgs[1])
+                    : astNode(args?.[0]);
+                return binding === undefined ? undefined : { binding, specifier };
+            }
+        }
+    }
+    if (callee?.type === "MemberExpression" || callee?.type === "OptionalMemberExpression") {
+        const method = memberPropertyName(callee);
+        if (method === "call") {
+            const binding = commonJsCallableBinding(astNode(callee.object));
+            return binding === undefined ? undefined : { binding, specifier: astNode(args?.[1]) };
+        }
+        if (method === "apply") {
+            const binding = commonJsCallableBinding(astNode(callee.object));
+            const applied = unwrapErasedExpression(astNode(args?.[1]));
+            const elements = applied?.type === "ArrayExpression" && ArrayIsArray(applied.elements)
+                ? applied.elements
+                : undefined;
+            return binding === undefined ? undefined : { binding, specifier: astNode(elements?.[0]) };
+        }
+    }
+    const binding = commonJsCallableBinding(callee);
+    return binding === undefined ? undefined : { binding, specifier: astNode(args?.[0]) };
+}
+function isErasedTypeScriptBinding(path) {
+    for (let current = path; current; current = current.parentPath) {
+        if (current.node.declare === true)
+            return true;
+        if ((current.node.type === "ImportDeclaration" || current.node.type === "ImportSpecifier" ||
+            current.node.type === "TSImportEqualsDeclaration") &&
+            current.node.importKind === "type") {
+            return true;
+        }
+    }
+    return false;
+}
+function namespaceMemberEmitsRuntime(value) {
+    const node = astNode(value);
+    if (!node)
         return false;
+    if (node.type === "ExportNamedDeclaration") {
+        const declaration = astNode(node.declaration);
+        if (declaration !== undefined)
+            return namespaceMemberEmitsRuntime(declaration);
+        if (node.exportKind === "type")
+            return false;
+        return ArrayIsArray(node.specifiers) &&
+            arraySome(node.specifiers, (specifier) => astNode(specifier)?.exportKind !== "type");
+    }
+    if (node.type === "TSModuleDeclaration") {
+        if (node.declare === true)
+            return false;
+        const body = astNode(node.body);
+        return body?.type === "TSModuleBlock" && ArrayIsArray(body.body) &&
+            arraySome(body.body, namespaceMemberEmitsRuntime);
     }
-    return body.directives.some((entry) => isRecord(entry) && isRecord(entry.value) && entry.value.value === directive);
+    if (node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration" ||
+        node.type === "TSNamespaceExportDeclaration" || node.type === "EmptyStatement") {
+        return false;
+    }
+    if ((node.type === "ImportDeclaration" || node.type === "TSImportEqualsDeclaration") &&
+        node.importKind === "type") {
+        return false;
+    }
+    return true;
+}
+function bodyHasRuntimeNamespaceBinding(body, name) {
+    if (!ArrayIsArray(body))
+        return false;
+    return arraySome(body, (entry) => {
+        let declaration = astNode(entry);
+        if (declaration?.type === "ExportNamedDeclaration") {
+            declaration = astNode(declaration.declaration);
+        }
+        if (declaration?.type !== "TSModuleDeclaration" || declaration.declare === true)
+            return false;
+        const identifier = astNode(declaration.id);
+        return identifier?.type === "Identifier" && identifier.name === name &&
+            namespaceMemberEmitsRuntime(declaration);
+    });
+}
+function hasRuntimeNamespaceBinding(path, name) {
+    for (let current = path; current; current = current.parentPath) {
+        if ((current.node.type === "Program" || current.node.type === "TSModuleBlock") &&
+            bodyHasRuntimeNamespaceBinding(current.node.body, name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasRuntimeBinding(path, name) {
+    const binding = path.scope?.getBinding(name);
+    return (binding !== undefined && !isErasedTypeScriptBinding(binding.path)) ||
+        hasRuntimeNamespaceBinding(path, name);
 }
 class BabelCodeParser extends BabelParseOnlyParser {
     traverse(ast, visitor) {
@@ -75,6 +385,30 @@ class BabelCodeParser extends BabelParseOnlyParser {
         this.traverse(ast, visitor);
         return found;
     }
+    async findStaticCommonJsImports(options) {
+        assertCommonJsAnalysisPrimitives();
+        const ast = await this.parse({
+            ...options,
+            allowReturnOutsideFunction: true,
+        });
+        assertCommonJsAnalysisPrimitives();
+        const imports = [];
+        const visit = (path) => {
+            const target = commonJsCallTarget(path.node);
+            if (!target || hasRuntimeBinding(path, target.binding))
+                return;
+            const specifier = staticStringValue(target.specifier);
+            if (specifier !== undefined)
+                arrayPush(imports, specifier);
+        };
+        traverse(ast, {
+            CallExpression: visit,
+            NewExpression: visit,
+            OptionalCallExpression: visit,
+        });
+        assertCommonJsAnalysisPrimitives();
+        return imports;
+    }
     injectJsxNodePositions(source, options) {
         return injectNodePositions(source, options);
     }

package/esm/parser-only.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser-only.d.ts","sourceRoot":"","sources":["../src/parser-only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEzE,wEAAwE;AACxE,MAAM,WAAW,4BAA4B;IAC3C,sEAAsE;IACtE,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD;AA0BD;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,4BAA4B;IACvE,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;CAQ/C"}
+{"version":3,"file":"parser-only.d.ts","sourceRoot":"","sources":["../src/parser-only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEzE,wEAAwE;AACxE,MAAM,WAAW,4BAA4B;IAC3C,sEAAsE;IACtE,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD;AA0BD;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,4BAA4B;IACvE,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;CAW/C"}

package/esm/parser-only.js

@@ -39,11 +39,14 @@ function pickPlugins(filePath) {
  */
 export class BabelParseOnlyParser {
     parse(options) {
+        const filePath = options.filePath?.toLowerCase() ?? "";
         const ast = parser.parse(options.code, {
             sourceType: "unambiguous",
-            allowReturnOutsideFunction: options.filePath?.toLowerCase().endsWith(".cjs") === true,
+            allowReturnOutsideFunction: options.allowReturnOutsideFunction === true ||
+                /\.(?:cjs|js)$/.test(filePath),
             plugins: pickPlugins(options.filePath),
         });
-        return Promise.resolve(ast);
+        const node = ast;
+        return Promise.resolve(node);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-parser-babel",
-  "version": "0.1.1238",
+  "version": "0.1.1240",
   "description": "Veryfront first-party extension package for ext-parser-babel",
   "keywords": [
     "veryfront",
@@ -46,13 +46,16 @@
     "capabilities": []
   },
   "dependencies": {
+    "@deno/shim-deno": "~0.18.0",
+    "@deno/shim-crypto": "~0.3.1",
+    "@deno/shim-timers": "~0.1.0",
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
     "@babel/types": "7.29.0"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1238"
+    "veryfront": "^0.1.1240"
   },
   "type": "module",
   "types": "./esm/index.d.ts",