@flex-development/mlly 1.0.0-alpha.1

package/dist/interfaces/options-resolve.d.mts

@@ -0,0 +1,60 @@
+/**
+ * @file Interfaces - ResolveOptions
+ * @module mlly/interfaces/ResolveOptions
+ */
+/// <reference types="node" />
+import type { Ext, SpecifierType } from '../types/index.mjs';
+import type { EmptyString } from '@flex-development/tutils';
+import type { URL } from 'node:url';
+/**
+ * Module resolution options.
+ */
+interface ResolveOptions {
+    /**
+     * Export conditions.
+     *
+     * **Note**: Should be sorted by priority.
+     *
+     * @see https://nodejs.org/api/packages.html#conditional-exports
+     *
+     * @default CONDITIONS
+     */
+    conditions?: Set<string> | string[] | readonly string[];
+    /**
+     * Remove or replace file extension.
+     *
+     * **Note**: {@link type} must be set to `relative`.
+     *
+     * @see {@link Ext}
+     */
+    ext?: Ext | false | ((specifier: string, resolved: string) => EmptyString | Ext | PromiseLike<EmptyString | Ext>);
+    /**
+     * Module extensions to probe for.
+     *
+     * **Note**: Should be sorted by priority.
+     *
+     * @default RESOLVE_EXTENSIONS
+     */
+    extensions?: string[] | readonly string[];
+    /**
+     * Parent module URL or path to resolve from.
+     *
+     * @default import.meta.url
+     */
+    parent?: URL | string;
+    /**
+     * Keep symlinks instead of resolving them.
+     *
+     * @default false
+     */
+    preserveSymlinks?: boolean;
+    /**
+     * Module specifier type or a function to determine module specifier type.
+     *
+     * @see {@link SpecifierType}
+     *
+     * @default 'absolute'
+     */
+    type?: SpecifierType | ((resolved: string) => PromiseLike<SpecifierType> | SpecifierType);
+}
+export type { ResolveOptions as default };

package/dist/interfaces/statement-export.d.mts

@@ -0,0 +1,31 @@
+/**
+ * @file Interfaces - ExportStatement
+ * @module mlly/interfaces/ExportStatement
+ */
+import type { Declaration } from '../types/index.mjs';
+import type Statement from './statement.mjs';
+/**
+ * Export statement object schema.
+ *
+ * @see {@link Declaration}
+ * @see {@link Statement}
+ *
+ * @extends {Statement}
+ */
+interface ExportStatement extends Statement {
+    /**
+     * Export declaration, if any.
+     *
+     * @see {@link Declaration}
+     */
+    declaration: Declaration | undefined;
+    /**
+     * Export names.
+     */
+    exports: string[];
+    /**
+     * Export statement type.
+     */
+    type: 'declaration' | 'default' | 'named' | 'star';
+}
+export type { ExportStatement as default };

package/dist/interfaces/statement-import.d.mts

@@ -0,0 +1,27 @@
+/**
+ * @file Interfaces - ImportStatement
+ * @module mlly/interfaces/ImportStatement
+ */
+import type Statement from './statement.mjs';
+/**
+ * Import statement object schema.
+ *
+ * @see {@link Statement}
+ *
+ * @extends {Statement}
+ */
+interface ImportStatement extends Statement {
+    /**
+     * Import names.
+     */
+    imports: string[];
+    /**
+     * Module specifier.
+     */
+    specifier: NonNullable<Statement['specifier']>;
+    /**
+     * Import statement type.
+     */
+    type: 'default' | 'dynamic' | 'named' | 'star';
+}
+export type { ImportStatement as default };

package/dist/interfaces/statement-require.d.mts

@@ -0,0 +1,27 @@
+/**
+ * @file Interfaces - RequireStatement
+ * @module mlly/interfaces/RequireStatement
+ */
+import type Statement from './statement.mjs';
+/**
+ * Require statement object schema.
+ *
+ * @see {@link Statement}
+ *
+ * @extends {Statement}
+ */
+interface RequireStatement extends Statement {
+    /**
+     * Import names.
+     */
+    imports: string[];
+    /**
+     * Module specifier.
+     */
+    specifier: NonNullable<Statement['specifier']>;
+    /**
+     * Import statement type.
+     */
+    type: 'require';
+}
+export type { RequireStatement as default };

package/dist/interfaces/statement.d.mts

@@ -0,0 +1,33 @@
+/**
+ * @file Interfaces - Statement
+ * @module mlly/interfaces/Statement
+ */
+import type { StatementType } from '../types/index.mjs';
+/**
+ * CommonJS or ESM statement object schema.
+ *
+ * @see {@link StatementType}
+ */
+interface Statement {
+    /**
+     * Statement snippet.
+     */
+    code: string;
+    /**
+     * Ending index of {@link code} in source content.
+     */
+    end: number;
+    /**
+     * Module specifier.
+     */
+    specifier: string | undefined;
+    /**
+     * Starting index of {@link code} in source content.
+     */
+    start: number;
+    /**
+     * Statement type.
+     */
+    type: StatementType;
+}
+export type { Statement as default };

package/dist/internal/compiler-options-json.d.mts

@@ -0,0 +1,111 @@
+/**
+ * @file Internals - CompilerOptionsJson
+ * @module mlly/internal/CompilerOptionsJson
+ */
+import type { CompilerOptionsValue, MapLike } from 'typescript';
+/**
+ * TypeScript compiler options provided by a user.
+ *
+ * @internal
+ *
+ * @see https://www.typescriptlang.org/tsconfig
+ */
+interface CompilerOptionsJson {
+    allowJs?: boolean;
+    allowSyntheticDefaultImports?: boolean;
+    allowUmdGlobalAccess?: boolean;
+    allowUnreachableCode?: boolean;
+    allowUnusedLabels?: boolean;
+    alwaysStrict?: boolean;
+    assumeChangesOnlyAffectDirectDependencies?: boolean;
+    baseUrl?: string;
+    charset?: string;
+    checkJs?: boolean;
+    composite?: boolean;
+    declaration?: boolean;
+    declarationDir?: string;
+    declarationMap?: boolean;
+    disableReferencedProjectLoad?: boolean;
+    disableSizeLimit?: boolean;
+    disableSolutionSearching?: boolean;
+    disableSourceOfProjectReferenceRedirect?: boolean;
+    downlevelIteration?: boolean;
+    emitBOM?: boolean;
+    emitDeclarationOnly?: boolean;
+    emitDecoratorMetadata?: boolean;
+    esModuleInterop?: boolean;
+    exactOptionalPropertyTypes?: boolean;
+    experimentalDecorators?: boolean;
+    forceConsistentCasingInFileNames?: boolean;
+    importHelpers?: boolean;
+    importsNotUsedAsValues?: 'error' | 'preserve' | 'remove';
+    incremental?: boolean;
+    inlineSourceMap?: boolean;
+    inlineSources?: boolean;
+    isolatedModules?: boolean;
+    jsx?: 'preserve' | 'react-jsx' | 'react-jsxdev' | 'react-native' | 'react';
+    jsxFactory?: string;
+    jsxFragmentFactory?: string;
+    jsxImportSource?: string;
+    keyofStringsOnly?: boolean;
+    lib?: ('DOM.Iterable' | 'dom.iterable' | 'DOM' | 'dom' | 'ES5' | 'es5' | 'ES6' | 'es6' | 'ES7' | 'es7' | 'ES2015.Collection' | 'es2015.collection' | 'ES2015.Core' | 'es2015.core' | 'ES2015.Generator' | 'es2015.generator' | 'ES2015.Iterable' | 'es2015.iterable' | 'ES2015.Promise' | 'es2015.promise' | 'ES2015.Proxy' | 'es2015.proxy' | 'ES2015.Reflect' | 'es2015.reflect' | 'ES2015.Symbol.WellKnown' | 'es2015.symbol.wellknown' | 'ES2015.Symbol' | 'es2015.symbol' | 'ES2015' | 'es2015' | 'ES2016.Array.Include' | 'es2016.array.include' | 'ES2016' | 'es2016' | 'ES2017.Intl' | 'es2017.intl' | 'ES2017.Object' | 'es2017.object' | 'ES2017.SharedMemory' | 'es2017.sharedmemory' | 'ES2017.String' | 'es2017.string' | 'ES2017.TypedArrays' | 'es2017.typedarrays' | 'ES2017' | 'es2017' | 'ES2018.AsyncGenerator' | 'es2018.asyncgenerator' | 'ES2018.AsyncIterable' | 'es2018.asynciterable' | 'ES2018.Intl' | 'es2018.intl' | 'ES2018.Promise' | 'es2018.promise' | 'ES2018.Regexp' | 'es2018.regexp' | 'ES2018' | 'es2018' | 'ES2019.Array' | 'es2019.array' | 'ES2019.Object' | 'es2019.object' | 'ES2019.String' | 'es2019.string' | 'ES2019.Symbol' | 'es2019.symbol' | 'ES2019' | 'es2019' | 'ES2020.BigInt' | 'es2020.bigint' | 'ES2020.Intl' | 'es2020.intl' | 'ES2020.Promise' | 'es2020.promise' | 'ES2020.SharedMemory' | 'es2020.sharedmemory' | 'ES2020.String' | 'es2020.string' | 'ES2020.Symbol.WellKnown' | 'es2020.symbol.wellknown' | 'ES2020' | 'es2020' | 'ES2021.Promise' | 'es2021.promise' | 'ES2021.String' | 'es2021.string' | 'ES2021.WeakRef' | 'es2021.weakref' | 'ES2021' | 'es2021' | 'ESNext.Array' | 'esnext.array' | 'ESNext.AsyncIterable' | 'esnext.asynciterable' | 'ESNext.BigInt' | 'esnext.bigint' | 'ESNext.Intl' | 'esnext.intl' | 'ESNext.Promise' | 'esnext.promise' | 'ESNext.String' | 'esnext.string' | 'ESNext.Symbol' | 'esnext.symbol' | 'ESNext.WeakRef' | 'esnext.weakref' | 'ESNext' | 'esnext' | 'ScriptHost' | 'scripthost' | 'WebWorker.ImportScripts' | 'webworker.importscripts' | 'WebWorker.Iterable' | 'webworker.iterable' | 'WebWorker' | 'webworker')[];
+    locale?: string;
+    mapRoot?: string;
+    maxNodeModuleJsDepth?: number;
+    module?: 'AMD' | 'amd' | 'CommonJS' | 'commonjs' | 'ES6' | 'es6' | 'ES2015' | 'es2015' | 'ES2020' | 'es2020' | 'ES2022' | 'es2022' | 'ESNext' | 'esnext' | 'Node16' | 'node16' | 'NodeNext' | 'nodenext' | 'None' | 'none' | 'System' | 'system' | 'UMD' | 'umd';
+    moduleDetection?: 'auto' | 'force' | 'legacy';
+    moduleResolution?: 'classic' | 'node' | 'node16' | 'nodenext';
+    moduleSuffixes?: string[];
+    newLine?: 'CRLF' | 'crlf' | 'LF' | 'lf';
+    noEmit?: boolean;
+    noEmitHelpers?: boolean;
+    noEmitOnError?: boolean;
+    noErrorTruncation?: boolean;
+    noFallthroughCasesInSwitch?: boolean;
+    noImplicitAny?: boolean;
+    noImplicitOverride?: boolean;
+    noImplicitReturns?: boolean;
+    noImplicitThis?: boolean;
+    noImplicitUseStrict?: boolean;
+    noLib?: boolean;
+    noPropertyAccessFromIndexSignature?: boolean;
+    noResolve?: boolean;
+    noStrictGenericChecks?: boolean;
+    noUncheckedIndexedAccess?: boolean;
+    noUnusedLocals?: boolean;
+    noUnusedParameters?: boolean;
+    out?: string;
+    outDir?: string;
+    outFile?: string;
+    paths?: MapLike<string[]>;
+    preserveConstEnums?: boolean;
+    preserveSymlinks?: boolean;
+    preserveValueImports?: boolean;
+    project?: string;
+    reactNamespace?: string;
+    removeComments?: boolean;
+    resolveJsonModule?: boolean;
+    rootDir?: string;
+    rootDirs?: string[];
+    skipDefaultLibCheck?: boolean;
+    skipLibCheck?: boolean;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    strict?: boolean;
+    strictBindCallApply?: boolean;
+    strictFunctionTypes?: boolean;
+    strictNullChecks?: boolean;
+    strictPropertyInitialization?: boolean;
+    stripInternal?: boolean;
+    suppressExcessPropertyErrors?: boolean;
+    suppressImplicitAnyIndexErrors?: boolean;
+    target?: 'ES3' | 'es3' | 'ES5' | 'es5' | 'ES6' | 'es6' | 'ES2015' | 'es2015' | 'ES2016' | 'es2016' | 'ES2017' | 'es2017' | 'ES2018' | 'es2018' | 'ES2019' | 'es2019' | 'ES2020' | 'es2020' | 'ES2021' | 'es2021' | 'ESNext' | 'esnext';
+    traceResolution?: boolean;
+    tsBuildInfoFile?: string;
+    typeRoots?: string[];
+    types?: string[];
+    useDefineForClassFields?: boolean;
+    useUnknownInCatchVariables?: boolean;
+    [option: string]: CompilerOptionsValue | undefined;
+}
+export type { CompilerOptionsJson as default };

package/dist/internal/constants.d.mts

@@ -0,0 +1,70 @@
+/**
+ * @file Internals - Constants
+ * @module mlly/internal/constants
+ */
+/**
+ * CommonJS syntax regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} CJS_SYNTAX_REGEX
+ */
+export declare const CJS_SYNTAX_REGEX: RegExp;
+/**
+ * Dynamic import statement regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} DYNAMIC_IMPORT_REGEX
+ */
+export declare const DYNAMIC_IMPORT_REGEX: RegExp;
+/**
+ * ESM syntax regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} ESM_SYNTAX_REGEX
+ */
+export declare const ESM_SYNTAX_REGEX: RegExp;
+/**
+ * Declaration export statement regex.
+ *
+ * **Note**: Captures [declaration type][1] and export name only.
+ *
+ * [1]: ./types/declaration.ts
+ *
+ * @const {RegExp} EXPORT_DECLARATION_REGEX
+ */
+export declare const EXPORT_DECLARATION_REGEX: RegExp;
+/**
+ * Named export statement regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} EXPORT_NAMED_REGEX
+ */
+export declare const EXPORT_NAMED_REGEX: RegExp;
+/**
+ * Aggregate export statement (`export * ...`) regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} EXPORT_STAR_REGEX
+ */
+export declare const EXPORT_STAR_REGEX: RegExp;
+/**
+ * Require statement regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} REQUIRE_STATEMENT_REGEX
+ */
+export declare const REQUIRE_STATEMENT_REGEX: RegExp;
+/**
+ * Static import statement regex.
+ *
+ * @internal
+ *
+ * @const {RegExp} STATIC_IMPORT_REGEX
+ */
+export declare const STATIC_IMPORT_REGEX: RegExp;

package/dist/internal/constants.mjs

@@ -0,0 +1,18 @@
+const CJS_SYNTAX_REGEX = /(?<!(?:\/\/|\*).*)((?:module\.)?exports(?:\.\w+|(?<!\s+=))|require(?=\(.)|require\.\w+|__dirname|__filename|await import)/gm;
+const DYNAMIC_IMPORT_REGEX = /(?<!(?:\/\/|\*).*)(?:(?:const|let|var)(?:(?<name>\s+\w+\s*)|\s*{\s*(?<names>\w+(?:,\s*\w+)*)\s*}\s*)(?:\s*=\s*?)?.)?(?:await)?\s+import\s*\((?<expression>(?:[^()]+|\((?:[^()]+|\([^()]*\))*\))*)\)/gm;
+const ESM_SYNTAX_REGEX = /(?<!(?:\/\/|\*).*)((?:export|import)[\s\w*,{}]*(?=\sfrom)|export\b\s*(?:[*{]|async function|(?:abstract\s)?class|const|default|enum|function|interface|let|type|var)|await import|import\.meta\.(?:env(?:\.\w+)?|resolve|url))/gm;
+const EXPORT_DECLARATION_REGEX = /(?<!(?:\/\/|\*).*)\bexport(?: +declare)? +(?<declaration>(?:(?:abstract +)?class|(?:default +)?async +function\*?|(?:default +)?function\*?|default +async|default(?!(?: +async)? +function\*?)|(?:const +)?enum|const|interface|let|namespace|type(?! *{)|var)) +(?<name>[\w$]+(?!.*\b +=>))?/gm;
+const EXPORT_NAMED_REGEX = /(?<!(?:\/\/|\*).*)\bexport(?:\s+type)?\s+{(?<exports>[^}]+?)[\s,]*}(?:\s*from\s*["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][^\n;]*)?/gm;
+const EXPORT_STAR_REGEX = /(?<!(?:\/\/|\*).*)\bexport\s*\*(?:\s*as\s+(?<name>[\w$]+)\s+)?\s*(?:\s*from\s*["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][^\n;]*)?/gm;
+const REQUIRE_STATEMENT_REGEX = /(?<!(?:\/\/|\*).*)(?:\bconst[ {]+(?<imports>[\w\t\n\r $*,/]+)[ =}]+)?(?<type>\brequire(?:\.resolve)?)\(["'] *(?<specifier>(?<="\s*)[^"']*[^\s"'](?=\s*")|(?<=["']\s*)[^']*[^\s'](?=\s*')) *["']\)/gm;
+const STATIC_IMPORT_REGEX = /(?<!(?:\/\/|\*).*)(?<=\s|^|;)import\s*([\s"']*(?<imports>[\w\t\n\r $*,/{}]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][\s;]*/gm;
+export {
+  CJS_SYNTAX_REGEX,
+  DYNAMIC_IMPORT_REGEX,
+  ESM_SYNTAX_REGEX,
+  EXPORT_DECLARATION_REGEX,
+  EXPORT_NAMED_REGEX,
+  EXPORT_STAR_REGEX,
+  REQUIRE_STATEMENT_REGEX,
+  STATIC_IMPORT_REGEX
+};

package/dist/internal/get-compiler-options.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file Internals - getCompilerOptions
+ * @module mlly/internal/getCompilerOptions
+ */
+import type CompilerOptionsJson from './compiler-options-json.mjs';
+/**
+ * Retrieves TypeScript compiler options from `path`.
+ *
+ * Supports [`extends`][1].
+ *
+ * [1]: https://typescriptlang.org/tsconfig#extends
+ *
+ * @internal
+ *
+ * @param {string} [path=upath.resolve('tsconfig.json')] - Tsconfig path
+ * @param {(path: string) => boolean} [exists] - File existence checker
+ * @param {(filename: string) => string} [read] - File content reader
+ * @return {CompilerOptionsJson} User compiler options
+ */
+declare const getCompilerOptions: (path?: string, exists?: ((path: string) => boolean) | undefined, read?: ((filename: string) => string) | undefined) => CompilerOptionsJson;
+export default getCompilerOptions;

package/dist/internal/get-compiler-options.mjs

@@ -0,0 +1,14 @@
+import { loadTsconfig } from "tsconfig-paths/lib/tsconfig-loader.js";
+import upath from "upath";
+const getCompilerOptions = (path = upath.resolve("tsconfig.json"), exists, read) => {
+  const t = loadTsconfig(
+    path,
+    exists,
+    read
+  );
+  return !(t == null ? void 0 : t.compilerOptions) ? {} : t.compilerOptions;
+};
+var get_compiler_options_default = getCompilerOptions;
+export {
+  get_compiler_options_default as default
+};

package/dist/internal/index.d.mts

@@ -0,0 +1,7 @@
+/**
+ * @file Internals
+ * @module mlly/internal
+ */
+export type { default as CompilerOptionsJson } from './compiler-options-json.mjs';
+export * from './constants.mjs';
+export { default as getCompilerOptions } from './get-compiler-options.mjs';

package/dist/internal/index.mjs

@@ -0,0 +1,5 @@
+export * from "./constants.mjs";
+import { default as default2 } from "./get-compiler-options.mjs";
+export {
+  default2 as getCompilerOptions
+};

package/dist/lib/detect-syntax.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file detectSyntax
+ * @module mlly/lib/detectSyntax
+ */
+/**
+ * Detects if `code` contains CommonJS syntax, ESM syntax, or a mixture of both.
+ *
+ * Ignores matches in comments.
+ *
+ * @see {@link hasCJSSyntax}
+ * @see {@link hasESMSyntax}
+ *
+ * @param {string} code - Code to check
+ * @return {{ cjs: boolean; esm: boolean; mixed: boolean }} Detection result
+ */
+declare const detectSyntax: (code: string) => {
+    cjs: boolean;
+    esm: boolean;
+    mixed: boolean;
+};
+export default detectSyntax;

package/dist/lib/detect-syntax.mjs

@@ -0,0 +1,11 @@
+import hasCJSSyntax from "./has-cjs-syntax.mjs";
+import hasESMSyntax from "./has-esm-syntax.mjs";
+const detectSyntax = (code) => {
+  const cjs = hasCJSSyntax(code);
+  const esm = hasESMSyntax(code);
+  return { cjs, esm, mixed: cjs && esm };
+};
+var detect_syntax_default = detectSyntax;
+export {
+  detect_syntax_default as default
+};

package/dist/lib/extract-statements.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file extractStatements
+ * @module mlly/lib/extractStatements
+ */
+import type { Statement } from '../interfaces/index.mjs';
+/**
+ * Finds all `export`, `import`, `require`, and/or `require.resolve` statements
+ * in `code`.
+ *
+ * Ignores matches in comments.
+ *
+ * @see {@link findDynamicImports}
+ * @see {@link findExports}
+ * @see {@link findRequires}
+ * @see {@link findStaticImports}
+ *
+ * @param {string} [code=''] - Code to extract statements from
+ * @return {Statement[]} Extracted statements
+ */
+declare const extractStatements: (code?: string) => Statement[];
+export default extractStatements;

package/dist/lib/extract-statements.mjs

@@ -0,0 +1,18 @@
+import findDynamicImports from "./find-dynamic-imports.mjs";
+import findExports from "./find-exports.mjs";
+import findRequires from "./find-requires.mjs";
+import findStaticImports from "./find-static-imports.mjs";
+const extractStatements = (code = "") => {
+  if (!code)
+    return [];
+  return [
+    ...findDynamicImports(code),
+    ...findExports(code),
+    ...findRequires(code),
+    ...findStaticImports(code)
+  ];
+};
+var extract_statements_default = extractStatements;
+export {
+  extract_statements_default as default
+};

package/dist/lib/find-dynamic-imports.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @file findDynamicImports
+ * @module mlly/lib/findDynamicImports
+ */
+import type { DynamicImport } from '../interfaces/index.mjs';
+/**
+ * Finds all dynamic import statements in `code`. Ignores matches in comments.
+ *
+ * @see {@link DynamicImport}
+ *
+ * @param {string} code - Code to check
+ * @return {DynamicImport[]} Dynamic import statement objects
+ */
+declare const findDynamicImports: (code: string) => DynamicImport[];
+export default findDynamicImports;

package/dist/lib/find-dynamic-imports.mjs

@@ -0,0 +1,20 @@
+import { DYNAMIC_IMPORT_REGEX } from "../internal/index.mjs";
+const findDynamicImports = (code) => {
+  return [...code.matchAll(DYNAMIC_IMPORT_REGEX)].map((match) => {
+    const { 0: statement = "", index: start = 0, groups = {} } = match;
+    const { expression = "", name = "", names = "" } = groups;
+    return {
+      code: statement,
+      end: start + statement.length,
+      imports: name.trim() ? [name.trim()] : names.trim() ? names.split(",").map((name2) => name2.trim()) : [],
+      specifier: expression.replace(/["']/g, ""),
+      specifier_type: /^["']/g.test(expression) ? "static" : "dynamic",
+      start,
+      type: "dynamic"
+    };
+  });
+};
+var find_dynamic_imports_default = findDynamicImports;
+export {
+  find_dynamic_imports_default as default
+};

package/dist/lib/find-exports.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @file findExports
+ * @module mlly/lib/findExports
+ */
+import type { ExportStatement } from '../interfaces/index.mjs';
+/**
+ * Finds all export statements in `code`. Ignores matches in comments.
+ *
+ * @see {@link ExportStatement}
+ *
+ * @param {string} code - Code to check
+ * @return {ExportStatement[]} Export statement objects
+ */
+declare const findExports: (code: string) => ExportStatement[];
+export default findExports;

package/dist/lib/find-exports.mjs

@@ -0,0 +1,53 @@
+import {
+  EXPORT_DECLARATION_REGEX,
+  EXPORT_NAMED_REGEX,
+  EXPORT_STAR_REGEX
+} from "../internal/index.mjs";
+const findExports = (code) => {
+  const statements = [];
+  for (const match of code.matchAll(EXPORT_DECLARATION_REGEX)) {
+    const { 0: statement = "", index: start = 0, groups = {} } = match;
+    const { declaration = "default", name = "" } = groups;
+    const stmt = statement.trim();
+    statements.push({
+      code: stmt,
+      declaration,
+      end: start + stmt.length,
+      exports: [name === "" ? "default" : name.trim()],
+      specifier: void 0,
+      start,
+      type: declaration === "default" ? "default" : "declaration"
+    });
+  }
+  for (const match of code.matchAll(EXPORT_NAMED_REGEX)) {
+    const { 0: statement = "", index: start = 0, groups = {} } = match;
+    const { exports: exp = "", specifier = "" } = groups;
+    statements.push({
+      code: statement,
+      declaration: void 0,
+      end: start + statement.length,
+      exports: exp.split(",").map((name) => name.trim()),
+      specifier,
+      start,
+      type: exp.trim() === "default" ? "default" : "named"
+    });
+  }
+  for (const match of code.matchAll(EXPORT_STAR_REGEX)) {
+    const { 0: statement = "", index: start = 0, groups = {} } = match;
+    const { name = "*", specifier = "" } = groups;
+    statements.push({
+      code: statement,
+      declaration: void 0,
+      end: start + statement.length,
+      exports: [name === "*" ? name : name.replace(/(\w+)/, "* as $1").trim()],
+      specifier,
+      start,
+      type: "star"
+    });
+  }
+  return statements;
+};
+var find_exports_default = findExports;
+export {
+  find_exports_default as default
+};

package/dist/lib/find-requires.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file findRequires
+ * @module mlly/lib/findRequires
+ */
+import type { RequireStatement } from '../interfaces/index.mjs';
+/**
+ * Finds all `require` and `require.resolve` statements in `code`.
+ *
+ * Ignores matches in comments.
+ *
+ * @see {@link RequireStatement}
+ *
+ * @param {string} code - Code to check
+ * @return {RequireStatement[]} Require statement objects
+ */
+declare const findRequires: (code: string) => RequireStatement[];
+export default findRequires;