@ogygia/core 0.0.0 → 0.11.1

package/dist/compiler/debarrel/barrel.js

@@ -0,0 +1,248 @@
+import { analyze_exports } from "./parse.js";
+// src/compiler/debarrel/barrel.ts
+/**
+* The barrel index: for a resolved module id, the map `exported name → leaf` — the module and
+* name an importer can go to directly. Built by walking the barrel's re-exports through nested
+* barrels, `export *` fan-outs and `import … ; export { … }` bindings, with a cycle guard and an
+* `opaque` flag for the parts it cannot see (a star into something it cannot parse).
+*
+* Pure over an injected HOST (read a file, resolve a specifier, decide candidacy), so it is
+* unit-tested against fixture files with a tiny resolver and runs unchanged inside the Vite plugin
+* with `this.resolve`.
+*
+* CONCURRENCY: a bundler transforms hundreds of importers at once, and most of them ask for the same
+* few barrels. One build per barrel is kept in flight (`#pending`) and every concurrent caller awaits
+* it. A cycle is detected against the WALK STACK of the build that is running (a → b → a), never
+* against another build's in-flight state; when a walk meets a barrel some other walk is still
+* building, it does not wait (two walks waiting on each other would never finish) — it leaves that
+* name unresolved and marks its own map PROVISIONAL, so the map is served once but not cached, and
+* the next importer rebuilds it against the finished neighbour.
+*/
+const STRIP_QUERY_RE = /[?#].*$/;
+const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+const PARSABLE_RE = /\.(?:[cm]?[jt]sx?|svelte\.[jt]s)$/;
+var BarrelIndex = class {
+	#host;
+	#maps = /* @__PURE__ */ new Map();
+	#shapes = /* @__PURE__ */ new Map();
+	#pending = /* @__PURE__ */ new Map();
+	constructor(host) {
+		this.#host = host;
+	}
+	/** Drop every cached map/shape that depends on `id` (the file changed). */
+	invalidate(id) {
+		const clean = id.replace(STRIP_QUERY_RE, "");
+		this.#shapes.delete(clean);
+		for (const [k, m] of this.#maps) if (k === clean || m && m.deps.has(clean)) this.#maps.delete(k);
+	}
+	/** The parsed shape of a module (cached), or null when it cannot be read/parsed. */
+	shape(id) {
+		const clean = id.replace(STRIP_QUERY_RE, "");
+		if (this.#shapes.has(clean)) return this.#shapes.get(clean);
+		let shape = null;
+		if (PARSABLE_RE.test(clean)) {
+			const code = this.#host.read(clean);
+			if (code != null) shape = analyze_exports(code, clean);
+		}
+		this.#shapes.set(clean, shape);
+		return shape;
+	}
+	/**
+	* The export map of a barrel, or null when the module is not a barrel the plugin may rewrite
+	* (not a candidate, impure and not forced, kept, unreadable). `spec` is the specifier the
+	* importer wrote — matchers see both. Concurrent callers share one build.
+	*/
+	async map(id, spec) {
+		const clean = id.replace(STRIP_QUERY_RE, "");
+		if (clean !== id) return null;
+		if (this.#host.kept(clean, spec)) return null;
+		if (!this.#host.candidate(clean, spec)) return null;
+		if (this.#maps.has(clean)) return this.#maps.get(clean);
+		const pending = this.#pending.get(clean);
+		if (pending) return pending;
+		const shape = this.shape(clean);
+		if (!shape) {
+			this.#maps.set(clean, null);
+			return null;
+		}
+		if (!shape.pure && !this.#host.forced(clean, spec)) {
+			this.#maps.set(clean, null);
+			return null;
+		}
+		return this.#start(clean, shape, /* @__PURE__ */ new Set());
+	}
+	/** Begin one build for `id`, register it as in flight, cache the result unless provisional. */
+	#start(id, shape, walk) {
+		const run = (async () => {
+			try {
+				const built = await this.#build(id, shape, walk);
+				if (!built.provisional && built.cycles.size === 0) this.#maps.set(id, built);
+				return built;
+			} finally {
+				this.#pending.delete(id);
+			}
+		})();
+		this.#pending.set(id, run);
+		return run;
+	}
+	async #build(id, shape, outer) {
+		const walk = new Set(outer);
+		walk.add(id);
+		const map = {
+			id,
+			entries: /* @__PURE__ */ new Map(),
+			pure: shape.pure,
+			rewritable: true,
+			opaque: false,
+			deps: /* @__PURE__ */ new Set([id]),
+			provisional: false,
+			cycles: /* @__PURE__ */ new Set()
+		};
+		const stars = [];
+		const explicit = /* @__PURE__ */ new Set();
+		for (const rec of shape.exports) if (rec.kind === "own") {
+			map.entries.set(rec.exported, "own");
+			explicit.add(rec.exported);
+		} else if (rec.kind === "reexport") {
+			explicit.add(rec.exported);
+			const leaf = await this.#leaf(id, rec.source, rec.imported, map, walk);
+			if (leaf) map.entries.set(rec.exported, leaf);
+			else map.opaque = true;
+		} else if (rec.kind === "star_ns") {
+			explicit.add(rec.exported);
+			const target = await this.#host.resolve(rec.source, id);
+			if (target) map.entries.set(rec.exported, {
+				id: target.replace(STRIP_QUERY_RE, ""),
+				namespace: true
+			});
+			else map.opaque = true;
+		} else stars.push({
+			source: rec.source,
+			type_only: rec.type_only
+		});
+		for (const star of stars) {
+			const target = await this.#host.resolve(star.source, id);
+			if (!target || target !== target.replace(STRIP_QUERY_RE, "")) {
+				map.opaque = true;
+				continue;
+			}
+			if (!this.#host.follow_packages && NODE_MODULES_RE.test(target)) {
+				map.opaque = true;
+				continue;
+			}
+			map.deps.add(target);
+			const names = await this.#star_names(target, map, walk);
+			if (!names) {
+				map.opaque = true;
+				continue;
+			}
+			for (const [name, leaf] of names) {
+				if (name === "default") continue;
+				if (explicit.has(name)) continue;
+				const existing = map.entries.get(name);
+				if (existing === void 0) map.entries.set(name, leaf);
+				else if (existing !== leaf && !same_leaf(existing, leaf)) map.entries.set(name, "ambiguous");
+			}
+		}
+		return map;
+	}
+	/** The leaf behind `import { imported } from source` written inside barrel `from`. */
+	async #leaf(from, source, imported, map, walk) {
+		const target = await this.#host.resolve(source, from);
+		if (!target) return null;
+		if (target !== target.replace(STRIP_QUERY_RE, "")) return null;
+		map.deps.add(target);
+		const inner = await this.#through(target, map, walk);
+		if (inner) {
+			const e = inner.entries.get(imported);
+			if (e && e !== "own" && e !== "ambiguous") return e;
+			if (e === "ambiguous") return null;
+		}
+		return {
+			id: target,
+			name: imported
+		};
+	}
+	/**
+	* Look through a nested module while building a map. Unlike `map()`, this does not require
+	* the nested module to be a CANDIDATE (an importer's rewrite policy) — only that it is pure:
+	* a pure nested barrel is transparent, an impure one is a leaf in its own right (its own code
+	* must run for the name to exist). On our own walk stack = a cycle (null); in flight on another
+	* walk = do not wait (null, and the parent becomes provisional).
+	*/
+	async #through(id, parent, walk) {
+		if (this.#host.kept(id, id)) return null;
+		if (this.#maps.has(id)) {
+			const m = this.#maps.get(id) ?? null;
+			if (m) for (const d of m.deps) parent.deps.add(d);
+			return m;
+		}
+		if (walk.has(id)) {
+			if (id !== parent.id) parent.cycles.add(id);
+			return null;
+		}
+		if (this.#pending.has(id)) {
+			parent.provisional = true;
+			return null;
+		}
+		const shape = this.shape(id);
+		if (!shape || !shape.pure) return null;
+		const built = await this.#start(id, shape, walk);
+		if (built.provisional) parent.provisional = true;
+		for (const c of built.cycles) if (c !== parent.id) parent.cycles.add(c);
+		for (const d of built.deps) parent.deps.add(d);
+		return built;
+	}
+	/** Every non-default name `export * from target` contributes, mapped to its leaf. */
+	async #star_names(target, parent, walk) {
+		const shape = this.shape(target);
+		if (!shape) return null;
+		const out = /* @__PURE__ */ new Map();
+		if (shape.pure) {
+			const inner = await this.#through(target, parent, walk);
+			if (!inner) return null;
+			if (inner.opaque) parent.opaque = true;
+			for (const [name, e] of inner.entries) if (e === "own") out.set(name, {
+				id: target,
+				name
+			});
+			else if (e !== "ambiguous") out.set(name, e);
+			return out;
+		}
+		for (const rec of shape.exports) if (rec.kind === "own") out.set(rec.exported, {
+			id: target,
+			name: rec.exported
+		});
+		else if (rec.kind === "reexport") {
+			const leaf = await this.#leaf(target, rec.source, rec.imported, parent, walk);
+			if (leaf) out.set(rec.exported, leaf);
+			else parent.opaque = true;
+		} else if (rec.kind === "star_ns") {
+			const t = await this.#host.resolve(rec.source, target);
+			if (t) out.set(rec.exported, {
+				id: t.replace(STRIP_QUERY_RE, ""),
+				namespace: true
+			});
+		} else {
+			const t = await this.#host.resolve(rec.source, target);
+			if (!t) {
+				parent.opaque = true;
+				continue;
+			}
+			parent.deps.add(t);
+			const names = await this.#star_names(t, parent, walk);
+			if (!names) {
+				parent.opaque = true;
+				continue;
+			}
+			for (const [n, leaf] of names) if (n !== "default" && !out.has(n)) out.set(n, leaf);
+		}
+		return out;
+	}
+};
+function same_leaf(a, b) {
+	if (typeof a === "string" || typeof b === "string") return a === b;
+	if ("namespace" in a || "namespace" in b) return "namespace" in a && "namespace" in b && a.id === b.id;
+	return a.id === b.id && a.name === b.name;
+}
+export { BarrelIndex };

package/dist/compiler/debarrel/options.d.ts

@@ -0,0 +1,67 @@
+/**
+ * `ogygia({ barrels })` — what counts as a barrel, which importers get rewritten, what to keep.
+ *
+ * A BARREL is a module whose exports are re-exports of other modules: `index.ts` files, a package's
+ * `components.ts`, `export * from` fan-outs. Importing one name from it drags the whole graph in: in
+ * dev every module behind it is transformed and served, in build the chunk graph follows the import
+ * graph before tree-shaking, and a package that is not `sideEffects: false` keeps all of it. The
+ * debarrel pass replaces `import { A } from 'barrel'` with `import A from '<leaf of A>'` at
+ * transform time, so the graph is the leaves the file actually uses.
+ *
+ * This pass is independent of islands: it does not read or write region marks. An import that
+ * carries ogygia attributes (`with { wake }` …) is left exactly as written — a barrel binding is
+ * marked through `asRegion` / a mark in the barrel, as before.
+ */
+export type Matcher = string | RegExp | ((id: string) => boolean);
+export interface DebarrelOptions {
+  /**
+   * DEPENDENCIES whose barrels may be bypassed too. The project's own modules need no listing:
+   * every file outside `node_modules` is a candidate, and purity decides (a barrel is PURE when
+   * every top-level statement is an import, a re-export, a type, or `export {}`). Packages are
+   * opt-in because Vite pre-bundles bare imports in dev: a leaf import that skips the optimizer
+   * while another importer gets the pre-bundled copy is two instances of one module. List a
+   * package here when you know it is safe (an ESM component library, excluded from
+   * `optimizeDeps`). Names, globs or regexes: `['@acme/ui', '@acme/*', /\/components\/index\.js$/]`.
+   * A plain string matches the specifier prefix (`'@acme/ui'` covers `@acme/ui/components`).
+   */
+  packages?: Matcher[];
+  /**
+   * Modules that are IMPURE barrels (own top-level code next to the re-exports) but should still
+   * be rewritten: the re-exported names go to their leaves, the barrel itself stays imported for
+   * its side effects (`import 'barrel'`). Without this, an impure barrel is left alone.
+   */
+  force?: Matcher[];
+  /** Never rewrite imports of these modules, whatever else says (a barrel whose own module-level
+   *  code the app depends on — a store singleton created in the barrel itself). */
+  keep?: Matcher[];
+  /** Which IMPORTERS are rewritten. Default: project files (not `node_modules`) with a JS / TS /
+   *  Svelte extension. */
+  importers?: {
+    include?: Matcher[];
+    exclude?: Matcher[];
+  };
+  /** Follow `export * from` into `node_modules` packages when building a barrel's export map
+   *  (default true). A star that reaches something unparsable (CJS, JSON) makes the barrel
+   *  OPAQUE for the names it cannot see: those stay on the barrel import. */
+  followPackages?: boolean;
+  /** A report at the end of each build leg — files rewritten, imports and names moved, barrels
+   *  bypassed, time spent in the pass, then the barrels by names moved. Default `true`: the eight
+   *  biggest and a count of the rest; `'all'`: every barrel; `false`: nothing. */
+  report?: boolean | "all";
+  /** Log every rewrite as it happens (dev + build). */
+  debug?: boolean;
+}
+export interface NormalizedOptions {
+  packages: Matcher[];
+  force: Matcher[];
+  keep: Matcher[];
+  importer_include: Matcher[];
+  importer_exclude: Matcher[];
+  follow_packages: boolean;
+  report: false | true | "all";
+  debug: boolean;
+}
+export declare function normalize_options(o?: DebarrelOptions | true): NormalizedOptions;
+/** Does `m` match `id` (a resolved file id) or `spec` (the bare specifier as written)? */
+export declare function matches(m: Matcher, id: string, spec: string): boolean;
+export declare function matches_any(ms: Matcher[], id: string, spec: string): boolean;

package/dist/compiler/debarrel/options.js

@@ -0,0 +1,31 @@
+// src/compiler/debarrel/options.ts
+function normalize_options(o = {}) {
+	const opts = o === true ? {} : o;
+	return {
+		packages: opts.packages ?? [],
+		force: opts.force ?? [],
+		keep: opts.keep ?? [],
+		importer_include: opts.importers?.include ?? [],
+		importer_exclude: opts.importers?.exclude ?? [],
+		follow_packages: opts.followPackages ?? true,
+		report: opts.report === false ? false : opts.report === "all" ? "all" : true,
+		debug: !!opts.debug
+	};
+}
+const GLOB_STAR_G = /\*/g;
+const REGEX_META_G = /[.+?^${}()|[\]\\]/g;
+/** Does `m` match `id` (a resolved file id) or `spec` (the bare specifier as written)? */
+function matches(m, id, spec) {
+	if (typeof m === "function") return m(id) || m(spec);
+	if (m instanceof RegExp) return m.test(id) || m.test(spec);
+	if (m.includes("*")) {
+		const re = new RegExp("^" + m.replace(REGEX_META_G, "\\$&").replace(GLOB_STAR_G, ".*") + "$");
+		return re.test(spec) || re.test(id) || re.test(id.split("/node_modules/").pop() ?? id);
+	}
+	return spec === m || spec.startsWith(m + "/") || id.includes("/" + m + "/") || id.endsWith("/" + m) || id === m;
+}
+function matches_any(ms, id, spec) {
+	for (const m of ms) if (matches(m, id, spec)) return true;
+	return false;
+}
+export { matches, matches_any, normalize_options };

package/dist/compiler/debarrel/parse.d.ts

@@ -0,0 +1,65 @@
+export interface ImportSpec {
+  /** `default` | `namespace` | `named` */
+  kind: "default" | "namespace" | "named";
+  /** the exported name asked for (`x` in `{ x as y }`, `default` for a default import) */
+  imported: string;
+  /** the local binding */
+  local: string;
+  /** `import { type T }` */
+  type_only: boolean;
+}
+export interface ImportDecl {
+  start: number;
+  end: number;
+  source: string;
+  /** the verbatim ` with { … }` clause (leading space included), '' when none */
+  attributes: string;
+  /** the attribute keys (`wake` in `with { wake: 'load' }`) — what a mark-aware caller inspects */
+  attribute_keys: string[];
+  /** `import type { … }` — the whole declaration is type-only */
+  type_only: boolean;
+  /** bare `import 'x'` */
+  side_effect: boolean;
+  specs: ImportSpec[];
+}
+/** What a barrel says about one of its exported names. */
+export type ExportRecord = {
+  kind: "reexport";
+  exported: string;
+  imported: string;
+  source: string;
+  type_only: boolean;
+} | {
+  kind: "star";
+  source: string;
+  type_only: boolean;
+} | {
+  kind: "star_ns";
+  exported: string;
+  source: string;
+} | {
+  kind: "own";
+  exported: string;
+};
+export interface ModuleShape {
+  imports: ImportDecl[];
+  exports: ExportRecord[];
+  /** A PURE barrel: nothing but imports, re-exports, type declarations and `export {}`. */
+  pure: boolean;
+  /** Own names (declared in this module) that are exported. */
+  own: Set<string>;
+}
+/**
+ * Every top-level import of the module, with ranges the rewriter overwrites. Declarations that
+ * cannot be rewritten (bare side-effect imports, namespace imports) are returned too, flagged, so
+ * a caller sees the whole picture. Null on a syntax error.
+ */
+export declare function analyze_imports(code: string, id: string): ImportDecl[] | null;
+/**
+ * The export shape of a module. `pure` is the barrel test: the module contributes NO code of its
+ * own — every statement is an import, a re-export, an `export {}` of imported bindings, a type
+ * declaration, or an empty export. A module with any own declaration, expression statement, or
+ * `export default <expr>` is IMPURE (it runs something), and is only rewritten when forced.
+ * Null on a syntax error (or a file oxc cannot read as a module).
+ */
+export declare function analyze_exports(code: string, id: string): ModuleShape | null;

package/dist/compiler/debarrel/parse.js

@@ -0,0 +1,256 @@
+import { parse_module } from "../parse/oxc.js";
+// src/compiler/debarrel/parse.ts
+/**
+* Module analysis on the compiler's parser ({@link parse_module} — oxc through Vite, TS understood,
+* byte offsets exact): the import declarations an importer has, and the export SHAPE of a candidate
+* barrel. The id's extension picks the dialect, like everywhere else in the compiler; a Svelte
+* script block is parsed under a synthetic `<file>.svelte.ts` / `.svelte.js` id.
+*/
+const name_of = (n) => {
+	if (!n) return "";
+	if (n.type === "Identifier") return n.name ?? "";
+	return typeof n.value === "string" ? n.value : String(n.value);
+};
+/** The clause runs from ` with` (or the legacy ` assert`) after the source literal to the end. */
+const ATTRIBUTES_CLAUSE_RE = /\s+(?:with|assert)\s*\{[\s\S]*\}/;
+const TRAILING_SEMI_RE = /;\s*$/;
+/** The parsed program body, or null on a syntax error (the real compiler reports those). */
+function program_body(code, id) {
+	const { program, ok } = parse_module(code, id);
+	if (!ok || !program) return null;
+	return program.body;
+}
+/** The verbatim ` with { … }` text of a declaration, from the source (oxc keeps `attributes`). */
+function attributes_text(code, node) {
+	const attrs = node.attributes;
+	if (!attrs || attrs.length === 0) return "";
+	const source = node.source;
+	const tail = code.slice(source.end, node.end);
+	const m = ATTRIBUTES_CLAUSE_RE.exec(tail);
+	return m ? m[0].replace(TRAILING_SEMI_RE, "") : "";
+}
+function attribute_keys(node) {
+	const attrs = node.attributes;
+	if (!attrs || attrs.length === 0) return [];
+	return attrs.map((a) => name_of(a.key));
+}
+function imports_of(code, body) {
+	const out = [];
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration") continue;
+		const source = node.source;
+		const specifiers = node.specifiers ?? [];
+		const specs = specifiers.map((s) => {
+			const local = name_of(s.local);
+			if (s.type === "ImportDefaultSpecifier") return {
+				kind: "default",
+				imported: "default",
+				local,
+				type_only: false
+			};
+			if (s.type === "ImportNamespaceSpecifier") return {
+				kind: "namespace",
+				imported: "*",
+				local,
+				type_only: false
+			};
+			return {
+				kind: "named",
+				imported: name_of(s.imported),
+				local,
+				type_only: s.importKind === "type"
+			};
+		});
+		out.push({
+			start: node.start,
+			end: node.end,
+			source: source.value,
+			attributes: attributes_text(code, node),
+			attribute_keys: attribute_keys(node),
+			type_only: node.importKind === "type",
+			side_effect: specifiers.length === 0,
+			specs
+		});
+	}
+	return out;
+}
+/**
+* Every top-level import of the module, with ranges the rewriter overwrites. Declarations that
+* cannot be rewritten (bare side-effect imports, namespace imports) are returned too, flagged, so
+* a caller sees the whole picture. Null on a syntax error.
+*/
+function analyze_imports(code, id) {
+	const body = program_body(code, id);
+	return body ? imports_of(code, body) : null;
+}
+/** Declarations erased at runtime — they never make a module impure. (Enums have runtime shape.) */
+const TYPE_ONLY_DECLS = /* @__PURE__ */ new Set([
+	"TSTypeAliasDeclaration",
+	"TSInterfaceDeclaration",
+	"TSDeclareFunction",
+	"TSModuleDeclaration"
+]);
+/**
+* The export shape of a module. `pure` is the barrel test: the module contributes NO code of its
+* own — every statement is an import, a re-export, an `export {}` of imported bindings, a type
+* declaration, or an empty export. A module with any own declaration, expression statement, or
+* `export default <expr>` is IMPURE (it runs something), and is only rewritten when forced.
+* Null on a syntax error (or a file oxc cannot read as a module).
+*/
+function analyze_exports(code, id) {
+	const body = program_body(code, id);
+	if (!body) return null;
+	const imports = imports_of(code, body);
+	const bound = /* @__PURE__ */ new Map();
+	for (const d of imports) for (const s of d.specs) bound.set(s.local, {
+		source: d.source,
+		imported: s.imported,
+		kind: s.kind
+	});
+	const exports = [];
+	const own = /* @__PURE__ */ new Set();
+	let pure = true;
+	for (const node of body) switch (node.type) {
+		case "ImportDeclaration": continue;
+		case "ExportAllDeclaration": {
+			const source = node.source.value;
+			const exported = node.exported;
+			if (exported) exports.push({
+				kind: "star_ns",
+				exported: name_of(exported),
+				source
+			});
+			else exports.push({
+				kind: "star",
+				source,
+				type_only: node.exportKind === "type"
+			});
+			continue;
+		}
+		case "ExportNamedDeclaration": {
+			const decl = node.declaration;
+			if (decl) {
+				if (TYPE_ONLY_DECLS.has(decl.type)) {
+					for (const n of declared_names(decl)) exports.push({
+						kind: "own",
+						exported: n
+					});
+					continue;
+				}
+				pure = false;
+				for (const n of declared_names(decl)) {
+					own.add(n);
+					exports.push({
+						kind: "own",
+						exported: n
+					});
+				}
+				continue;
+			}
+			const source = node.source ? node.source.value : null;
+			const specifiers = node.specifiers ?? [];
+			const type_decl = node.exportKind === "type";
+			for (const s of specifiers) {
+				const local = name_of(s.local);
+				const exported = name_of(s.exported);
+				const type_only = type_decl || s.exportKind === "type";
+				if (source) {
+					exports.push({
+						kind: "reexport",
+						exported,
+						imported: local,
+						source,
+						type_only
+					});
+					continue;
+				}
+				const b = bound.get(local);
+				if (b) {
+					if (b.kind === "namespace") exports.push({
+						kind: "star_ns",
+						exported,
+						source: b.source
+					});
+					else exports.push({
+						kind: "reexport",
+						exported,
+						imported: b.imported,
+						source: b.source,
+						type_only
+					});
+				} else {
+					own.add(exported);
+					exports.push({
+						kind: "own",
+						exported
+					});
+					if (!type_only) pure = false;
+				}
+			}
+			continue;
+		}
+		case "ExportDefaultDeclaration": {
+			const decl = node.declaration;
+			if (decl.type === "Identifier") {
+				const b = bound.get(name_of(decl));
+				if (b && b.kind !== "namespace") {
+					exports.push({
+						kind: "reexport",
+						exported: "default",
+						imported: b.imported,
+						source: b.source,
+						type_only: false
+					});
+					continue;
+				}
+			}
+			pure = false;
+			own.add("default");
+			exports.push({
+				kind: "own",
+				exported: "default"
+			});
+			continue;
+		}
+		default:
+			if (TYPE_ONLY_DECLS.has(node.type)) continue;
+			if (node.type === "EmptyStatement") continue;
+			pure = false;
+	}
+	return {
+		imports,
+		exports,
+		pure,
+		own
+	};
+}
+/** Names a declaration binds (`const { a, b } = …`, `function f`, `class C`, `enum E`, `type T`). */
+function declared_names(decl) {
+	const out = [];
+	const id = decl.id;
+	if (id && id.type === "Identifier") out.push(name_of(id));
+	const declarations = decl.declarations;
+	if (declarations) for (const d of declarations) collect_pattern(d.id, out);
+	return out;
+}
+function collect_pattern(p, out) {
+	if (!p) return;
+	switch (p.type) {
+		case "Identifier":
+			out.push(name_of(p));
+			return;
+		case "ObjectPattern":
+			for (const prop of p.properties) collect_pattern(prop.type === "RestElement" ? prop.argument : prop.value, out);
+			return;
+		case "ArrayPattern":
+			for (const el of p.elements) if (el) collect_pattern(el, out);
+			return;
+		case "AssignmentPattern":
+			collect_pattern(p.left, out);
+			return;
+		case "RestElement":
+			collect_pattern(p.argument, out);
+			return;
+	}
+}
+export { analyze_exports, analyze_imports };