@absolutejs/changelog 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,4 +1,7 @@
 // @bun
+// src/apply.ts
+import ts from "typescript";
+
 // src/types.ts
 var CHANGE_KINDS = [
   "breaking",
@@ -19,141 +22,272 @@ var isDisruptive = (change) => change.kind === "breaking" || change.kind === "re
 var isMechanical = (migration) => !("manual" in migration);
 
 // src/apply.ts
-var IS_CODE = -1;
-var IMPORT = /(?:import|export)\s+(?:type\s+)?(?<clause>[\s\S]*?)\s*from\s*(?<quote>['"])(?<module>[^'"]+)\k<quote>/gu;
-var importsOf = (source) => {
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+var SPECIFIER = /^[@a-zA-Z0-9._~-][a-zA-Z0-9._~/-]*$/u;
+var applyEdits = (source, edits) => [...edits].sort((left, right) => right.start - left.start).reduce((out, edit) => out.slice(0, edit.start) + edit.text + out.slice(edit.end), source);
+var kindOf = (path) => /\.[cm]?ts$/u.test(path) ? ts.ScriptKind.TS : ts.ScriptKind.TSX;
+var parse = (source, path) => ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, kindOf(path));
+var belongsTo = (specifier, name) => specifier === name || specifier.startsWith(`${name}/`);
+var moduleTextOf = (statement) => statement.moduleSpecifier !== undefined && ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+var portsOf = (file) => {
   const found = [];
-  for (const match of source.matchAll(IMPORT)) {
-    const { clause, module } = match.groups ?? {};
-    if (module === undefined || match.index === undefined)
+  for (const statement of file.statements) {
+    if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
       continue;
-    const braced = clause === undefined ? undefined : /\{([\s\S]*)\}/u.exec(clause);
-    found.push({
-      clause: braced?.[1],
-      end: match.index + match[0].length,
-      full: match[0],
-      module,
-      start: match.index
-    });
+    const module = moduleTextOf(statement);
+    if (module !== undefined)
+      found.push({ module, statement });
   }
   return found;
 };
-var belongsTo = (specifier, name) => specifier === name || specifier.startsWith(`${name}/`);
-var skipEnd = (source, index) => {
-  const character = source[index];
-  const next = source[index + 1];
-  if (character === "/" && next === "/") {
-    const line = source.indexOf(`
-`, index);
-    return line < 0 ? source.length : line;
-  }
-  if (character === "/" && next === "*") {
-    const close = source.indexOf("*/", index + 2);
-    return close < 0 ? source.length : close + 2;
-  }
-  if (character !== "'" && character !== '"' && character !== "`")
-    return IS_CODE;
-  let cursor = index + 1;
-  while (cursor < source.length && source[cursor] !== character)
-    cursor += source[cursor] === "\\" ? 2 : 1;
-  return Math.min(cursor + 1, source.length);
-};
-var codeSpans = (source) => {
-  const spans = [];
-  let start = 0;
-  let index = 0;
-  const closeSpan = (ends, resumes) => {
-    spans.push([start, ends]);
-    start = resumes;
+var namedElementsOf = (statement) => {
+  const clause = ts.isImportDeclaration(statement) ? statement.importClause?.namedBindings : statement.exportClause;
+  if (clause === undefined)
+    return;
+  if (ts.isNamedImports(clause) || ts.isNamedExports(clause))
+    return clause;
+  return;
+};
+var exportedNameOf = (element) => (element.propertyName ?? element.name).text;
+var declaresLocally = (file, name) => {
+  let found = false;
+  const visit = (node) => {
+    if (found)
+      return;
+    const declares = (ts.isVariableDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isParameter(node) || ts.isBindingElement(node)) && node.name !== undefined && ts.isIdentifier(node.name) && node.name.text === name;
+    if (declares)
+      found = true;
+    else
+      ts.forEachChild(node, visit);
   };
-  while (index < source.length) {
-    const skipped = skipEnd(source, index);
-    if (skipped > IS_CODE)
-      closeSpan(index, skipped);
-    index = skipped === IS_CODE ? index + 1 : skipped;
-  }
-  spans.push([start, source.length]);
-  return spans;
-};
-var renameInCode = (source, from, into) => {
-  const pattern = new RegExp(`(?<![.\\w$])${from.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}(?![\\w$])`, "gu");
-  let out = "";
-  let cursor = 0;
-  for (const [start, end] of codeSpans(source)) {
-    out += source.slice(cursor, start);
-    out += source.slice(start, end).replace(pattern, into);
-    cursor = end;
-  }
-  return out + source.slice(cursor);
-};
-var declaresLocally = (source, name) => new RegExp(`\\b(?:const|let|var|function|class|interface|type|enum)\\s+${name.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(source);
-var applyRename = (source, packageName, rename) => {
-  const statements = importsOf(source).filter((statement) => belongsTo(statement.module, packageName) && statement.clause !== undefined && new RegExp(`(?<![\\w$])${rename.from}(?![\\w$])`, "u").test(statement.clause));
-  if (statements.length === 0)
-    return { changed: false, notes: [], source };
-  const aliased = statements.some((statement) => new RegExp(`(?<![\\w$])${rename.from}\\s+as\\s`, "u").test(statement.clause ?? ""));
-  if (aliased) {
-    let out = source;
-    for (const statement of statements)
-      out = out.replace(statement.full, statement.full.replace(new RegExp(`(?<![\\w$])${rename.from}(\\s+as\\s)`, "u"), `${rename.to}$1`));
-    return { changed: true, notes: [], source: out };
-  }
-  if (declaresLocally(source, rename.from)) {
-    let out = source;
-    for (const statement of statements)
-      out = out.replace(statement.full, statement.full.replace(new RegExp(`(?<![\\w$])${rename.from}(?![\\w$])`, "u"), `${rename.to} as ${rename.from}`));
+  ts.forEachChild(file, visit);
+  return found;
+};
+var isReference = (node) => {
+  const { parent } = node;
+  if (parent === undefined)
+    return false;
+  if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+    return false;
+  if (ts.isQualifiedName(parent) && parent.right === node)
+    return false;
+  if (ts.isPropertyAssignment(parent) && parent.name === node)
+    return false;
+  if (ts.isBindingElement(parent) && parent.propertyName === node)
+    return false;
+  if (ts.isJsxAttribute(parent) && parent.name === node)
+    return false;
+  if ((ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertySignature(parent) || ts.isMethodSignature(parent) || ts.isEnumMember(parent)) && parent.name === node)
+    return false;
+  if ((ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent)) && true)
+    return false;
+  return !ts.isDeclarationStatement(parent);
+};
+var referencesTo = (file, name) => {
+  const found = [];
+  const shorthand = [];
+  const visit = (node) => {
+    if (ts.isShorthandPropertyAssignment(node) && node.name.text === name)
+      shorthand.push(node);
+    else if (ts.isIdentifier(node) && node.text === name && isReference(node))
+      found.push(node);
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(file, visit);
+  return { references: found, shorthand };
+};
+var withoutElement = (elements, dropped, file) => {
+  const kept = elements.filter((element) => element !== dropped);
+  return kept.length === 0 ? undefined : kept.map((element) => element.getText(file)).join(", ");
+};
+var isTypeOnly = (statement, element) => {
+  if (element.isTypeOnly)
+    return true;
+  return ts.isImportDeclaration(statement) ? statement.importClause?.isTypeOnly === true : statement.isTypeOnly;
+};
+var quoteOf = (statement, file) => statement.moduleSpecifier?.getText(file).startsWith('"') === true ? '"' : "'";
+var renameTargetsIn = (input) => portsOf(input.file).filter(({ module }) => belongsTo(module, input.packageName)).flatMap(({ statement }) => {
+  const clause = namedElementsOf(statement);
+  if (clause === undefined)
+    return [];
+  return clause.elements.filter((element) => exportedNameOf(element) === input.from).map((element) => ({ clause, element }));
+});
+var renameOneImport = (input) => {
+  const { clause, element } = input.target;
+  const { file, rename } = input;
+  const already = element.propertyName === undefined && clause.elements.some((other) => other !== element && exportedNameOf(other) === rename.to);
+  if (already) {
+    const kept = withoutElement(clause.elements, element, file);
     return {
-      changed: true,
-      notes: [
-        `\`${rename.from}\` is also declared in this file, so the import was aliased instead of the uses being renamed`
+      edits: kept === undefined ? [] : [
+        {
+          end: clause.getEnd() - 1,
+          start: clause.getStart(file) + 1,
+          text: ` ${kept} `
+        }
+      ],
+      moves: true
+    };
+  }
+  if (element.propertyName !== undefined)
+    return {
+      edits: [
+        {
+          end: element.propertyName.getEnd(),
+          start: element.propertyName.getStart(file),
+          text: rename.to
+        }
       ],
-      source: out
+      moves: false
+    };
+  const shadowed = declaresLocally(file, rename.from);
+  return {
+    edits: [
+      {
+        end: element.getEnd(),
+        start: element.getStart(file),
+        text: shadowed ? `${rename.to} as ${rename.from}` : rename.to
+      }
+    ],
+    moves: !shadowed,
+    ...shadowed ? {
+      note: `\`${rename.from}\` is also declared in this file, so the import was aliased instead of the uses being renamed`
+    } : {}
+  };
+};
+var applyRename = (input) => {
+  const { file, packageName, rename, source } = input;
+  if (!IDENTIFIER.test(rename.to))
+    return {
+      changed: false,
+      notes: [`\`${rename.to}\` is not a name, so this rename was not applied`],
+      source
     };
+  const done = renameTargetsIn({ file, from: rename.from, packageName }).map((target) => renameOneImport({ file, rename, target }));
+  const edits = done.flatMap((one) => one.edits);
+  if (edits.length === 0)
+    return { changed: false, notes: [], source };
+  if (done.some((one) => one.moves)) {
+    const { references, shorthand } = referencesTo(file, rename.from);
+    for (const reference of references)
+      edits.push({
+        end: reference.getEnd(),
+        start: reference.getStart(file),
+        text: rename.to
+      });
+    for (const property of shorthand)
+      edits.push({
+        end: property.getEnd(),
+        start: property.getStart(file),
+        text: `${rename.from}: ${rename.to}`
+      });
   }
   return {
     changed: true,
-    notes: [],
-    source: renameInCode(source, rename.from, rename.to)
+    notes: done.flatMap((one) => ("note" in one) && one.note ? [one.note] : []),
+    source: applyEdits(source, edits)
   };
 };
-var applyResubpath = (source, resubpath) => {
-  const statements = importsOf(source).filter((statement) => statement.module === resubpath.from);
-  if (statements.length === 0)
-    return { changed: false, notes: [], source };
-  let out = source;
-  for (const statement of statements)
-    out = out.replace(statement.full, statement.full.replace(resubpath.from, resubpath.to));
-  return { changed: true, notes: [], source: out };
-};
-var applyMoved = (source, moved) => {
-  const pattern = new RegExp(`(?<![\\w$])${moved.symbol}(?![\\w$])`, "u");
-  const statements = importsOf(source).filter((statement) => statement.module === moved.from && statement.clause !== undefined && pattern.test(statement.clause));
-  if (statements.length === 0)
+var applyMoved = (input) => {
+  const { file, moved, source } = input;
+  if (!SPECIFIER.test(moved.to))
+    return {
+      changed: false,
+      notes: [
+        `\`${moved.to}\` is not a module specifier, so this move was not applied`
+      ],
+      source
+    };
+  const edits = [];
+  for (const { module, statement } of portsOf(file)) {
+    if (module !== moved.from)
+      continue;
+    const clause = namedElementsOf(statement);
+    if (clause === undefined)
+      continue;
+    const element = clause.elements.find((candidate) => exportedNameOf(candidate) === moved.symbol);
+    if (element === undefined)
+      continue;
+    const quote = quoteOf(statement, file);
+    const kept = withoutElement(clause.elements, element, file);
+    const carriesDefault = ts.isImportDeclaration(statement) && (statement.importClause?.name !== undefined || statement.importClause?.isTypeOnly === true);
+    const whole = kept === undefined && !carriesDefault && statement.moduleSpecifier;
+    if (whole)
+      edits.push({
+        end: whole.getEnd(),
+        start: whole.getStart(file),
+        text: `${quote}${moved.to}${quote}`
+      });
+    if (whole)
+      continue;
+    const keyword = ts.isExportDeclaration(statement) ? "export" : "import";
+    const typed = isTypeOnly(statement, element) ? "type " : "";
+    const carried = element.propertyName ? `${moved.symbol} as ${element.name.text}` : element.name.text;
+    const carrier = ts.isImportDeclaration(statement) && statement.importClause?.name;
+    const emptied = kept === undefined && carrier ? { end: clause.getEnd(), start: carrier.getEnd(), text: "" } : undefined;
+    const trimmed = kept === undefined ? undefined : {
+      end: clause.getEnd() - 1,
+      start: clause.getStart(file) + 1,
+      text: ` ${kept} `
+    };
+    edits.push(...[emptied, trimmed].filter((edit) => edit !== undefined));
+    edits.push({
+      end: statement.getEnd(),
+      start: statement.getEnd(),
+      text: `
+${keyword} ${typed}{ ${carried} } from ${quote}${moved.to}${quote};`
+    });
+  }
+  if (edits.length === 0)
     return { changed: false, notes: [], source };
-  let out = source;
-  for (const statement of statements) {
-    const clause = statement.clause ?? "";
-    const kept = clause.split(",").map((part) => part.trim()).filter((part) => part !== "" && !pattern.test(part));
-    const replacement = kept.length === 0 ? statement.full.replace(moved.from, moved.to) : `${statement.full.replace(clause, ` ${kept.join(", ")} `).replace(/\s+/gu, " ")}
-import { ${moved.symbol} } from '${moved.to}';`;
-    out = out.replace(statement.full, replacement);
+  return { changed: true, notes: [], source: applyEdits(source, edits) };
+};
+var applyResubpath = (input) => {
+  const { file, resubpath, source } = input;
+  if (!SPECIFIER.test(resubpath.to))
+    return {
+      changed: false,
+      notes: [
+        `\`${resubpath.to}\` is not a module specifier, so this move was not applied`
+      ],
+      source
+    };
+  const edits = [];
+  for (const { module, statement } of portsOf(file)) {
+    if (module !== resubpath.from || !statement.moduleSpecifier)
+      continue;
+    const quote = quoteOf(statement, file);
+    edits.push({
+      end: statement.moduleSpecifier.getEnd(),
+      start: statement.moduleSpecifier.getStart(file),
+      text: `${quote}${resubpath.to}${quote}`
+    });
   }
-  return { changed: true, notes: [], source: out };
+  if (edits.length === 0)
+    return { changed: false, notes: [], source };
+  return { changed: true, notes: [], source: applyEdits(source, edits) };
 };
 var applyMigration = (source, input) => {
   const { migration, packageName } = input;
   if (!isMechanical(migration))
     return { changed: false, notes: [migration.instruction], source };
+  const file = parse(source, input.path ?? "file.tsx");
   if ("rename" in migration)
-    return applyRename(source, packageName, migration.rename);
+    return applyRename({
+      file,
+      packageName,
+      rename: migration.rename,
+      source
+    });
   if ("resubpath" in migration)
-    return applyResubpath(source, migration.resubpath);
-  return applyMoved(source, migration.moved);
+    return applyResubpath({ file, resubpath: migration.resubpath, source });
+  return applyMoved({ file, moved: migration.moved, source });
 };
 var applyMigrations = (source, input) => input.migrations.reduce((carried, migration) => {
   const result = applyMigration(carried.source, {
     migration,
-    packageName: input.packageName
+    packageName: input.packageName,
+    ...input.path === undefined ? {} : { path: input.path }
   });
   return {
     changed: carried.changed || result.changed,
@@ -433,6 +567,10 @@ var migrationsBetween = (changelog, from, upto) => disruptiveBetween(changelog,
 });
 var symbolsDisturbedBetween = (changelog, from, upto) => new Set(disruptiveBetween(changelog, from, upto).flatMap(({ change: change2 }) => change2.symbols));
 
+// src/surface.ts
+import path from "path";
+import ts2 from "typescript";
+
 // src/tarball.ts
 var TAR_BLOCK = 512;
 var NAME_LENGTH = 100;
@@ -485,114 +623,185 @@ var readTar = (archive, keep, limits = {}) => {
 };
 
 // src/surface.ts
-var DECLARATION = /\bexport\s+(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(function|const|let|var|class|interface|type|enum|namespace)\s+([A-Za-z_$][\w$]*)/gu;
-var NAMED_EXPORT = /\bexport\s*\{([^}]*)\}/gu;
-var BODIED = new Set(["class", "interface", "enum", "namespace"]);
-var OPENS = new Set(["{", "(", "["]);
-var CLOSES = new Set(["}", ")", "]"]);
-var IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
-var LAST2 = -1;
-var NOWHERE = -1;
-var MEMBER = /([A-Za-z_$][\w$]*)\s*[?!]?\s*[:(<]/u;
-var isStub = (declaration) => declaration.startsWith("export {");
-var declarationEnd = (source, from, bodied) => {
-  let depth = 0;
-  for (let index = from;index < source.length; index += 1) {
-    const character = source[index] ?? "";
-    if (OPENS.has(character))
-      depth += 1;
-    else if (CLOSES.has(character))
-      depth -= 1;
-    else if (character === ";" && depth <= 0)
-      return index + 1;
-    if (CLOSES.has(character) && depth <= 0 && bodied)
-      return index + 1;
-  }
-  return source.length;
-};
-var normalize = (declaration) => declaration.replace(/\s+/gu, " ").trim();
-var reExported = (body) => body.split(",").map((part) => part.trim().replace(/^type\s+/u, "")).filter((clause) => clause !== "").map((clause) => [
-  clause.split(/\s+as\s+/u).at(LAST2)?.trim(),
-  clause
-]).filter((pair) => pair[0] !== undefined && IDENTIFIER.test(pair[0]));
-var exportedDeclarations = (source) => {
+var DECLARATION = /\.d\.[cm]?ts$/u;
+var parse2 = (source, name) => ts2.createSourceFile(name, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+var normalize = (text) => text.replace(/\s+/gu, " ").trim();
+var resolveFrom = (files, from, specifier) => {
+  if (!specifier.startsWith("."))
+    return;
+  const base = path.posix.join(path.posix.dirname(from), specifier);
+  const candidates = [
+    base,
+    `${base.replace(/\.js$/u, "")}.d.ts`,
+    `${base.replace(/\.js$/u, "")}.d.mts`,
+    `${base.replace(/\.js$/u, "")}.d.cts`,
+    `${base}/index.d.ts`,
+    `${base}/index.d.mts`,
+    `${base}/index.d.cts`
+  ];
+  return candidates.find((candidate) => files.has(candidate));
+};
+var declaredNameOf = (statement) => {
+  if (ts2.isFunctionDeclaration(statement) || ts2.isClassDeclaration(statement) || ts2.isInterfaceDeclaration(statement) || ts2.isTypeAliasDeclaration(statement) || ts2.isEnumDeclaration(statement) || ts2.isModuleDeclaration(statement))
+    return statement.name !== undefined && ts2.isIdentifier(statement.name) ? statement.name.text : undefined;
+  return;
+};
+var isExported = (statement) => ts2.canHaveModifiers(statement) && ts2.getModifiers(statement)?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword) === true;
+var variableNamesOf = (statement) => statement.declarationList.declarations.map((declaration) => declaration.name).filter((name) => ts2.isIdentifier(name)).map((name) => name.text);
+var declarationsIn = (file) => {
   const found = new Map;
-  const add = (name, declaration) => {
-    const existing = found.get(name);
-    found.set(name, existing === undefined ? declaration : `${existing}
-${declaration}`);
-  };
-  for (const match of source.matchAll(DECLARATION)) {
-    const [, keyword, name] = match;
-    if (name === undefined || match.index === undefined)
+  for (const statement of file.statements) {
+    const text = normalize(statement.getText(file));
+    const named = declaredNameOf(statement);
+    if (named !== undefined)
+      found.set(named, text);
+    if (!ts2.isVariableStatement(statement))
       continue;
-    add(name, normalize(source.slice(match.index, declarationEnd(source, match.index + match[0].length, BODIED.has(keyword ?? "")))));
+    for (const name of variableNamesOf(statement))
+      found.set(name, text);
   }
-  for (const match of source.matchAll(NAMED_EXPORT))
-    for (const [exported, clause] of reExported(match[1] ?? ""))
-      add(exported, `export { ${clause} }`);
   return found;
 };
-var surfaceOfArchive = (archive) => surfaceOfFiles([...readTar(archive, (path) => path.endsWith(".d.ts")).values()].map(asText));
-var surfaceOfFiles = (files) => {
+var declaresTypes = (manifest) => {
+  if (typeof manifest !== "object" || manifest === null)
+    return false;
+  const record = new Map(Object.entries(manifest));
+  if (typeof record.get("types") === "string")
+    return true;
+  if (typeof record.get("typings") === "string")
+    return true;
+  return JSON.stringify(record.get("exports") ?? {}).includes('"types"');
+};
+var contributionOf = (input) => {
+  const { file, files, from, local, seen, statement } = input;
+  const nothing = [];
+  if (ts2.isExportAssignment(statement))
+    return [
+      [
+        statement.isExportEquals === true ? "export=" : "default",
+        normalize(statement.getText(file))
+      ]
+    ];
+  const named = declaredNameOf(statement);
+  if (named !== undefined && isExported(statement))
+    return [
+      [named, local.get(named) ?? normalize(statement.getText(file))]
+    ];
+  if (ts2.isVariableStatement(statement) && isExported(statement)) {
+    const text = normalize(statement.getText(file));
+    return variableNamesOf(statement).map((name) => [name, text]);
+  }
+  if (!ts2.isExportDeclaration(statement))
+    return nothing;
+  const specifier = statement.moduleSpecifier !== undefined && ts2.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+  const target = specifier === undefined ? undefined : resolveFrom(files, from, specifier);
+  const theirs = target === undefined ? new Map : exportsOf(files, target, new Set(seen));
+  const clause = statement.exportClause;
+  if (clause === undefined)
+    return [...theirs].filter(([name]) => name !== "default" && name !== "export=");
+  if (ts2.isNamespaceExport(clause))
+    return [[clause.name.text, `export * as ${clause.name.text}`]];
+  return clause.elements.map((element) => {
+    const sourceName = (element.propertyName ?? element.name).text;
+    const text = (specifier === undefined ? local.get(sourceName) : theirs.get(sourceName)) ?? `export { ${sourceName} }`;
+    return [element.name.text, text];
+  });
+};
+var exportsOf = (files, from, seen) => {
   const surface = new Map;
-  for (const source of files)
-    for (const [name, declaration] of exportedDeclarations(source)) {
-      const known = surface.get(name);
-      if (known === undefined || isStub(known) && !isStub(declaration))
-        surface.set(name, declaration);
-    }
+  const source = files.get(from);
+  if (source === undefined || seen.has(from))
+    return surface;
+  seen.add(from);
+  const file = parse2(source, from);
+  const local = declarationsIn(file);
+  const contributed = file.statements.flatMap((statement) => contributionOf({ file, files, from, local, seen, statement }));
+  for (const [name, text] of contributed)
+    surface.set(name, text);
   return surface;
 };
+var surfaceOfArchive = (archive) => {
+  const held = readTar(archive, (name) => DECLARATION.test(name) || name === "package.json");
+  const files = new Map([...held].map(([name, bytes]) => [name, asText(bytes)]));
+  const manifest = files.get("package.json");
+  let parsed;
+  try {
+    parsed = manifest === undefined ? undefined : JSON.parse(manifest);
+  } catch {
+    parsed = undefined;
+  }
+  const entries = typeEntriesOf(parsed, files);
+  return entries.length === 0 ? undefined : surfaceOfFiles(files, entries);
+};
+var surfaceOfFiles = (files, entries) => {
+  const surface = new Map;
+  for (const entry of entries)
+    for (const [name, text] of exportsOf(files, entry, new Set))
+      if (!surface.has(name))
+        surface.set(name, text);
+  return surface;
+};
+var typeCandidatesIn = (value) => {
+  if (typeof value === "string")
+    return [value];
+  if (typeof value !== "object" || value === null)
+    return [];
+  return Object.entries(value).flatMap(([key, nested]) => key === "types" || key === "typings" ? typeCandidatesIn(nested) : typeCandidatesIn(nested));
+};
+var typeEntriesOf = (manifest, files) => {
+  const record = typeof manifest === "object" && manifest !== null ? new Map(Object.entries(manifest)) : new Map;
+  const claimed = [
+    record.get("types"),
+    record.get("typings"),
+    ...typeCandidatesIn(record.get("exports"))
+  ];
+  const entries = claimed.filter((value) => typeof value === "string").map((value) => value.replace(/^\.\//u, "")).flatMap((cleaned) => DECLARATION.test(cleaned) ? [cleaned] : [
+    cleaned.replace(/\.[cm]?js$/u, ".d.ts"),
+    cleaned.replace(/\.[cm]?js$/u, ".d.mts"),
+    cleaned.replace(/\.[cm]?js$/u, ".d.cts")
+  ]).filter((candidate) => files.has(candidate));
+  const fallback = entries.length === 0 && files.has("dist/index.d.ts") ? ["dist/index.d.ts"] : [];
+  return [...new Set([...entries, ...fallback])];
+};
 var SHAPE = {
   members: "members",
   parameters: "parameters",
   types: "types",
   unknown: "unknown"
 };
+var isStub = (declaration) => declaration.startsWith("export {");
+var signatureOf = (declaration) => {
+  const file = parse2(`${declaration}
+`, "declaration.d.ts");
+  const [statement] = file.statements;
+  if (statement === undefined)
+    return;
+  return statement;
+};
 var parametersOf = (declaration) => {
-  let depth = 0;
-  let start = NOWHERE;
-  for (const [index, character] of [...declaration].entries()) {
-    if (character === "{" && depth === 0)
-      return "";
-    depth += character === "(" ? 1 : 0;
-    if (character === "(" && depth === 1)
-      start = index;
-    depth -= character === ")" ? 1 : 0;
-    if (character === ")" && depth === 0 && start > NOWHERE)
-      return declaration.slice(start, index + 1);
-  }
-  return "";
+  const statement = signatureOf(declaration);
+  if (statement === undefined)
+    return "";
+  const found = [];
+  const visit = (node) => {
+    if (ts2.isFunctionTypeNode(node) || ts2.isFunctionDeclaration(node) || ts2.isMethodSignature(node) || ts2.isMethodDeclaration(node) || ts2.isConstructSignatureDeclaration(node) || ts2.isConstructorDeclaration(node))
+      found.push(node.parameters.map((parameter) => normalize(parameter.getText())).join(", "));
+    ts2.forEachChild(node, visit);
+  };
+  visit(statement);
+  return found.join(" | ");
 };
 var membersOf = (declaration) => {
-  const opened = declaration.indexOf("{");
-  if (opened < 0)
-    return new Set;
+  const statement = signatureOf(declaration);
   const members = new Set;
-  let depth = 0;
-  let segment = "";
-  const take = () => {
-    const [, name] = MEMBER.exec(segment.trim()) ?? [];
-    if (name !== undefined)
-      members.add(name);
-    segment = "";
+  if (statement === undefined)
+    return members;
+  const visit = (node) => {
+    if ((ts2.isPropertySignature(node) || ts2.isMethodSignature(node) || ts2.isPropertyDeclaration(node) || ts2.isMethodDeclaration(node) || ts2.isEnumMember(node)) && node.name !== undefined && (ts2.isIdentifier(node.name) || ts2.isStringLiteral(node.name)))
+      members.add(node.name.text);
+    ts2.forEachChild(node, visit);
   };
-  for (const character of declaration.slice(opened)) {
-    const opening = OPENS.has(character);
-    const closing = CLOSES.has(character);
-    depth += opening ? 1 : 0;
-    if (opening && depth === 1)
-      segment = "";
-    depth -= closing ? 1 : 0;
-    if (opening || closing || depth !== 1)
-      continue;
-    if (character === ";" || character === ",")
-      take();
-    else
-      segment += character;
-  }
-  take();
+  visit(statement);
   return members;
 };
 var sameNames = (left, right) => left.size === right.size && [...left].every((name) => right.has(name));
@@ -629,9 +838,9 @@ var diffSurface = (before, after) => {
 var notable = (diff) => diff.changed.filter((change2) => change2.shape === "parameters" || change2.shape === "members");
 
 // src/entries.ts
-var loadEntry = async (path) => {
+var loadEntry = async (path2) => {
   try {
-    const module = await import(pathToFileURL(path).href);
+    const module = await import(pathToFileURL(path2).href);
     const named = typeof module === "object" && module !== null && "change" in module ? module.change : undefined;
     const exported = named ?? (typeof module === "object" && module !== null && "default" in module ? module.default : undefined);
     const read = { exported };
@@ -644,23 +853,28 @@ var loadEntry = async (path) => {
   }
 };
 var ENTRY = /\.[cm]?ts$/u;
-var builtSurface = async (packageRoot, out = "dist") => {
-  const root = join(packageRoot, out);
-  const sources = [];
+var DECLARATION2 = /\.d\.[cm]?ts$/u;
+var OUTPUT_DIRECTORIES = ["dist", "build", "lib", "types", "out"];
+var builtSurface = async (packageRoot) => {
+  const manifest = await readJsonFile(join(packageRoot, "package.json"));
+  const files = new Map;
   const walk = async (directory) => {
-    const found = await readdir(directory, { withFileTypes: true }).catch(() => []);
+    const found = await readdir(join(packageRoot, directory), {
+      withFileTypes: true
+    }).catch(() => []);
     await Promise.all(found.map(async (entry) => {
-      const path = join(directory, entry.name);
+      const relative = `${directory}/${entry.name}`;
       if (entry.isDirectory())
-        return walk(path);
-      if (!entry.name.endsWith(".d.ts"))
+        return walk(relative);
+      if (!DECLARATION2.test(entry.name))
         return;
-      sources.push(await readFile(path, "utf8").catch(() => ""));
+      files.set(relative, await readFile(join(packageRoot, relative), "utf8").catch(() => ""));
       return;
     }));
   };
-  await walk(root);
-  return sources.length === 0 ? undefined : surfaceOfFiles(sources);
+  await Promise.all(OUTPUT_DIRECTORIES.map((directory) => walk(directory)));
+  const entries = typeEntriesOf(manifest, files);
+  return entries.length === 0 ? undefined : surfaceOfFiles(files, entries);
 };
 var changelogPaths = (packageRoot) => ({
   history: join(packageRoot, "changelog", "history.md"),
@@ -686,8 +900,8 @@ var loadUnreleased = async (packageRoot) => {
   }
   return { entries, problems };
 };
-var readJsonFile = async (path) => {
-  const source = await readFile(path, "utf8").catch(() => {
+var readJsonFile = async (path2) => {
+  const source = await readFile(path2, "utf8").catch(() => {
     return;
   });
   if (source === undefined)
@@ -737,8 +951,14 @@ var migrationHolds = (input) => {
 };
 var describeReconciliation = (found) => {
   const lines = [];
+  const moved2 = {
+    members: "changed the members of its type",
+    parameters: "changed what it is called with",
+    removed: "is no longer exported",
+    types: "changed its declaration"
+  };
   for (const entry of found.unannounced)
-    lines.push(entry.kind === "removed" ? `\`${entry.name}\` is no longer exported and no entry says so` : `\`${entry.name}\` changed its ${entry.kind} and no entry says so`);
+    lines.push(`\`${entry.name}\` ${moved2[entry.kind]} and no entry says so`);
   for (const name of found.unknownSymbols)
     lines.push(`an entry names \`${name}\`, which this package does not export`);
   lines.push(...found.wrongMigrations);
@@ -749,10 +969,7 @@ var reconcile = (input) => {
   const mentioned = new Set(input.changes.flatMap((change2) => [...change2.symbols ?? []]));
   const unannounced = [
     ...input.diff.removed.filter((name) => !disruptive.has(name)).map((name) => ({ kind: "removed", name })),
-    ...notable(input.diff).filter((change2) => !mentioned.has(change2.name)).map((change2) => ({
-      kind: change2.shape === "parameters" ? "parameters" : "members",
-      name: change2.name
-    }))
+    ...input.diff.changed.filter((change2) => !mentioned.has(change2.name) && change2.shape !== "unknown").map((change2) => ({ kind: change2.shape, name: change2.name }))
   ];
   const unknownSymbols = [
     ...new Set(input.changes.flatMap((change2) => [...change2.symbols ?? []]).filter((name) => !input.known.has(name)))
@@ -769,6 +986,16 @@ var reconcile = (input) => {
 import { gunzipSync } from "zlib";
 var ABBREVIATED = "application/vnd.npm.install-v1+json";
 var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var KIBIBYTE2 = 1024;
+var MEBIBYTE2 = KIBIBYTE2 * KIBIBYTE2;
+var MAX_ARCHIVE_MEBIBYTES = 96;
+var MAX_ARCHIVE_BYTES = MAX_ARCHIVE_MEBIBYTES * MEBIBYTE2;
+var MAX_DOWNLOAD_MEBIBYTES = 32;
+var MAX_DOWNLOAD_BYTES = MAX_DOWNLOAD_MEBIBYTES * MEBIBYTE2;
+var TIMEOUT_MS = 20000;
+var PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u;
+var MAX_NAME_LENGTH = 214;
+var isPackageName = (name) => name.length <= MAX_NAME_LENGTH && PACKAGE_NAME.test(name);
 var isRecord2 = (value) => typeof value === "object" && value !== null;
 var readPackument = (body) => {
   if (!isRecord2(body) || !isRecord2(body.versions))
@@ -796,20 +1023,30 @@ var packageArchive = async (name, version, options = {}) => {
   if (url === undefined)
     return;
   try {
-    const response = await call(url);
+    const response = await call(url, {
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
     if (!response.ok)
       return;
-    return new Uint8Array(gunzipSync(new Uint8Array(await response.arrayBuffer())));
+    const compressed = new Uint8Array(await response.arrayBuffer());
+    if (compressed.byteLength > MAX_DOWNLOAD_BYTES)
+      return;
+    return new Uint8Array(gunzipSync(compressed, { maxOutputLength: MAX_ARCHIVE_BYTES }));
   } catch {
     return;
   }
 };
 var packageVersions = async (name, options = {}) => {
+  if (!isPackageName(name))
+    return;
   const call = options.fetch ?? fetch;
   const url = `${options.registry ?? DEFAULT_REGISTRY}/${name.replace("/", "%2f")}`;
   try {
-    const abbreviated = await call(url, { headers: { accept: ABBREVIATED } });
-    const response = abbreviated.ok ? abbreviated : await call(url);
+    const abbreviated = await call(url, {
+      headers: { accept: ABBREVIATED },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+    const response = abbreviated.ok ? abbreviated : await call(url, { signal: AbortSignal.timeout(TIMEOUT_MS) });
     if (!response.ok)
       return;
     return readPackument(await response.json());
@@ -821,7 +1058,7 @@ var publishedChangelog = async (name, version, options = {}) => {
   const archive = await packageArchive(name, version, options);
   if (!archive)
     return;
-  const file = readTar(archive, (path) => path === CHANGELOG_FILE).get(CHANGELOG_FILE);
+  const file = readTar(archive, (path2) => path2 === CHANGELOG_FILE).get(CHANGELOG_FILE);
   if (!file)
     return;
   try {
@@ -898,6 +1135,7 @@ var renderRelease = (release) => {
   ].join(`
 `);
 };
+var GENERATED_MARKER = "This file is generated by `absolute-changelog`";
 var renderChangelogJson = (changelog) => `${JSON.stringify({
   contract: CHANGELOG_CONTRACT,
   name: changelog.name,
@@ -923,7 +1161,7 @@ var renderMarkdown = (changelog, options = {}) => {
     "",
     `All notable changes to \`${changelog.name}\`.`,
     "",
-    "This file is generated by `absolute-changelog` from the entries in",
+    `${GENERATED_MARKER} from the entries in`,
     "`changelog/`. Edit an entry, not this file \u2014 and add new ones under",
     "`changelog/unreleased/`."
   ].join(`
@@ -954,12 +1192,13 @@ export {
   changelogPaths,
   changesBetween,
   compareVersions,
+  declaresTypes,
   describeReconciliation,
   diffSurface,
   disruptiveBetween,
-  exportedDeclarations,
   isDisruptive,
   isMechanical,
+  isPackageName,
   isPrerelease,
   loadUnreleased,
   manual,
@@ -985,8 +1224,9 @@ export {
   surfaceOfArchive,
   surfaceOfFiles,
   symbolsDisturbedBetween,
+  typeEntriesOf,
   validateChange
 };
 
-//# debugId=7673E1441936CC9C64756E2164756E21
+//# debugId=7DC9C4F3C075733D64756E2164756E21
 //# sourceMappingURL=index.js.map