@absolutejs/changelog 0.1.0

package/dist/index.js

@@ -0,0 +1,946 @@
+// @bun
+// src/types.ts
+var CHANGE_KINDS = [
+  "breaking",
+  "removed",
+  "added",
+  "changed",
+  "deprecated",
+  "fixed",
+  "security",
+  "internal"
+];
+var DISRUPTIVE_KINDS = ["breaking", "removed"];
+var CHANGELOG_CONTRACT = 1;
+var CHANGELOG_FILE = "changelog.json";
+var CHANGELOG_MARKDOWN = "CHANGELOG.md";
+var UNRELEASED_DIRECTORY = "changelog/unreleased";
+var isDisruptive = (change) => change.kind === "breaking" || change.kind === "removed";
+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) => {
+  const found = [];
+  for (const match of source.matchAll(IMPORT)) {
+    const { clause, module } = match.groups ?? {};
+    if (module === undefined || match.index === undefined)
+      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
+    });
+  }
+  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;
+  };
+  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}`));
+    return {
+      changed: true,
+      notes: [
+        `\`${rename.from}\` is also declared in this file, so the import was aliased instead of the uses being renamed`
+      ],
+      source: out
+    };
+  }
+  return {
+    changed: true,
+    notes: [],
+    source: renameInCode(source, rename.from, rename.to)
+  };
+};
+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)
+    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: out };
+};
+var applyMigration = (source, input) => {
+  const { migration, packageName } = input;
+  if (!isMechanical(migration))
+    return { changed: false, notes: [migration.instruction], source };
+  if ("rename" in migration)
+    return applyRename(source, packageName, migration.rename);
+  if ("resubpath" in migration)
+    return applyResubpath(source, migration.resubpath);
+  return applyMoved(source, migration.moved);
+};
+var applyMigrations = (source, input) => input.migrations.reduce((carried, migration) => {
+  const result = applyMigration(carried.source, {
+    migration,
+    packageName: input.packageName
+  });
+  return {
+    changed: carried.changed || result.changed,
+    notes: [...carried.notes, ...result.notes],
+    source: result.source
+  };
+}, { changed: false, notes: [], source });
+// src/authoring.ts
+var change = (entry) => entry;
+var manual = (instruction) => ({
+  instruction,
+  manual: true
+});
+var moved = (input) => change({
+  ...input.detail === undefined ? {} : { detail: input.detail },
+  kind: "breaking",
+  migration: {
+    instruction: `Import \`${input.symbol}\` from \`${input.to}\`.`,
+    moved: { from: input.from, symbol: input.symbol, to: input.to }
+  },
+  ...input.reference === undefined ? {} : { reference: input.reference },
+  summary: `\`${input.symbol}\` moved to \`${input.to}\``,
+  symbols: [input.symbol]
+});
+var renamed = (input) => change({
+  ...input.detail === undefined ? {} : { detail: input.detail },
+  kind: "breaking",
+  migration: {
+    instruction: `Import \`${input.to}\` instead of \`${input.from}\`.`,
+    rename: { from: input.from, to: input.to }
+  },
+  ...input.reference === undefined ? {} : { reference: input.reference },
+  summary: `\`${input.from}\` is now \`${input.to}\``,
+  symbols: [input.from]
+});
+// src/entries.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
+
+// src/versioning.ts
+var OLDER = -1;
+var LAST = -1;
+var NEWER = 1;
+var VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u;
+var parseVersion = (version) => {
+  const found = VERSION.exec(version.trim());
+  if (!found)
+    return;
+  const [, major, minor, patch, prerelease] = found;
+  return {
+    prerelease: prerelease === undefined ? [] : prerelease.split("."),
+    release: [Number(major), Number(minor), Number(patch)]
+  };
+};
+var isNumeric = (value) => /^\d+$/u.test(value);
+var comparePrerelease = (left, right) => {
+  if (left.length === 0 || right.length === 0)
+    return right.length - left.length;
+  for (const [index, mine] of left.entries()) {
+    const theirs = right[index];
+    if (theirs === undefined)
+      return NEWER;
+    if (mine === theirs)
+      continue;
+    if (isNumeric(mine) && isNumeric(theirs))
+      return Number(mine) - Number(theirs);
+    if (isNumeric(mine))
+      return OLDER;
+    if (isNumeric(theirs))
+      return NEWER;
+    return mine < theirs ? OLDER : NEWER;
+  }
+  return left.length - right.length;
+};
+var compareVersions = (left, right) => {
+  const mine = parseVersion(left);
+  const theirs = parseVersion(right);
+  if (!mine || !theirs)
+    return 0;
+  for (const [index, part] of mine.release.entries()) {
+    const other = theirs.release[index] ?? 0;
+    if (part !== other)
+      return part - other;
+  }
+  return comparePrerelease(mine.prerelease, theirs.prerelease);
+};
+var isPrerelease = (version) => (parseVersion(version)?.prerelease.length ?? 0) > 0;
+var releaseKindFor = (changes) => {
+  if (changes.some(isDisruptive)) {
+    const major = "major";
+    return major;
+  }
+  const asked = changes.some((entry) => entry.kind === "added") ? "minor" : "patch";
+  return asked;
+};
+var bumpPrerelease = (parsed) => {
+  const { prerelease, release } = parsed;
+  const last = prerelease.at(LAST);
+  const counted = last !== undefined && isNumeric(last) ? [...prerelease.slice(0, LAST), String(Number(last) + 1)] : [...prerelease, "1"];
+  return `${release.join(".")}-${counted.join(".")}`;
+};
+var nextVersion = (input) => {
+  const parsed = parseVersion(input.current);
+  if (!parsed)
+    return;
+  const [major, minor, patch] = parsed.release;
+  const kind = input.asked ?? (parsed.prerelease.length > 0 ? "prerelease" : releaseKindFor(input.changes));
+  if (kind === "prerelease")
+    return parsed.prerelease.length > 0 ? bumpPrerelease(parsed) : `${major}.${minor}.${patch + 1}-${input.prereleaseIdentifier ?? "beta"}.1`;
+  if (parsed.prerelease.length > 0 && kind === "patch")
+    return `${major}.${minor}.${patch}`;
+  if (kind === "major")
+    return major === 0 ? `${major}.${minor + 1}.0` : `${major + 1}.0.0`;
+  return kind === "minor" ? `${major}.${minor + 1}.0` : `${major}.${minor}.${patch + 1}`;
+};
+
+// src/read.ts
+var isKind = (value) => typeof value === "string" && CHANGE_KINDS.some((known) => known === value);
+var isDisruptiveKind = (kind) => kind === "breaking" || kind === "removed";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isText = (value) => typeof value === "string" && value.trim().length > 0;
+var textList = (value) => Array.isArray(value) && value.length > 0 && value.every(isText) ? value : undefined;
+var readMigration = (value, where, problems) => {
+  if (!isRecord(value) || !isText(value.instruction)) {
+    problems.push(`${where}: migration needs an instruction`);
+    return;
+  }
+  const { instruction } = value;
+  const { rename } = value;
+  if (isRecord(rename) && isText(rename.from) && isText(rename.to))
+    return {
+      instruction,
+      rename: { from: rename.from, to: rename.to }
+    };
+  const { moved: moved2 } = value;
+  if (isRecord(moved2) && isText(moved2.symbol) && isText(moved2.from) && isText(moved2.to))
+    return {
+      instruction,
+      moved: { from: moved2.from, symbol: moved2.symbol, to: moved2.to }
+    };
+  const { resubpath } = value;
+  if (isRecord(resubpath) && isText(resubpath.from) && isText(resubpath.to))
+    return {
+      instruction,
+      resubpath: { from: resubpath.from, to: resubpath.to }
+    };
+  if (value.manual === true)
+    return { instruction, manual: true };
+  problems.push(`${where}: migration says neither rename, moved, resubpath nor manual`);
+  return;
+};
+var readChange = (value, where, problems) => {
+  if (!isRecord(value)) {
+    problems.push(`${where}: not an object`);
+    return;
+  }
+  const { kind } = value;
+  if (!isKind(kind)) {
+    problems.push(`${where}: unknown kind ${JSON.stringify(kind)}`);
+    return;
+  }
+  if (!isText(value.summary)) {
+    problems.push(`${where}: needs a summary`);
+    return;
+  }
+  const shared = {
+    ...isText(value.detail) ? { detail: value.detail } : {},
+    ...isText(value.reference) ? { reference: value.reference } : {},
+    summary: value.summary
+  };
+  const symbols = textList(value.symbols);
+  const [first, ...rest] = symbols ?? [];
+  if (kind === "breaking" || kind === "removed") {
+    const migration = readMigration(value.migration, where, problems);
+    if (first === undefined)
+      problems.push(`${where}: a ${kind} change must name symbols`);
+    if (!migration || first === undefined)
+      return;
+    const named = [first, ...rest];
+    const disruptive = {
+      ...shared,
+      kind,
+      migration,
+      symbols: named
+    };
+    return disruptive;
+  }
+  if (isDisruptiveKind(kind))
+    return;
+  const ordinary = {
+    ...shared,
+    kind,
+    ...symbols ? { symbols } : {}
+  };
+  return ordinary;
+};
+var readRelease = (value, where, problems) => {
+  if (!isRecord(value)) {
+    problems.push(`${where}: not an object`);
+    return;
+  }
+  if (!isText(value.version) || parseVersion(value.version) === undefined) {
+    problems.push(`${where}: version is not a version`);
+    return;
+  }
+  if (!isText(value.date)) {
+    problems.push(`${where}: needs a date`);
+    return;
+  }
+  const raw = value.changes;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    problems.push(`${where}: a release with no changes is not a release`);
+    return;
+  }
+  const changes = raw.map((entry, index) => readChange(entry, `${where}.changes[${index}]`, problems)).filter((entry) => entry !== undefined);
+  if (changes.length !== raw.length)
+    return;
+  const [head, ...tail] = changes;
+  if (head === undefined)
+    return;
+  const release = {
+    changes: [head, ...tail],
+    date: value.date,
+    ...isText(value.note) ? { note: value.note } : {},
+    version: value.version
+  };
+  return release;
+};
+var validateChange = (value, where = "entry") => {
+  const problems = [];
+  const change2 = readChange(value, where, problems);
+  if (change2 === undefined) {
+    const failed = { problems };
+    return failed;
+  }
+  const read = { change: change2 };
+  return read;
+};
+var parseChangelog = (value) => {
+  const problems = [];
+  if (!isRecord(value))
+    return { problems: ["not an object"] };
+  if (!isText(value.name))
+    problems.push("needs a package name");
+  if (value.contract !== CHANGELOG_CONTRACT)
+    problems.push(`contract ${JSON.stringify(value.contract)} is not ${CHANGELOG_CONTRACT}`);
+  const raw = value.releases;
+  if (!Array.isArray(raw))
+    problems.push("releases is not a list");
+  const releases = (Array.isArray(raw) ? raw : []).map((entry, index) => readRelease(entry, `releases[${index}]`, problems)).filter((entry) => entry !== undefined);
+  if (problems.length > 0)
+    return { problems };
+  return {
+    changelog: {
+      contract: CHANGELOG_CONTRACT,
+      name: String(value.name),
+      releases: [...releases].sort((left, right) => compareVersions(right.version, left.version))
+    }
+  };
+};
+var releasesBetween = (changelog, from, upto) => [...changelog.releases].filter((release) => compareVersions(release.version, from) > 0 && compareVersions(release.version, upto) <= 0).sort((left, right) => compareVersions(left.version, right.version));
+var changesBetween = (changelog, from, upto) => releasesBetween(changelog, from, upto).flatMap((release) => release.changes.map((change2) => {
+  const found = { change: change2, version: release.version };
+  return found;
+}));
+var isDisruptiveAt = (found) => isDisruptive(found.change);
+var disruptiveBetween = (changelog, from, upto) => changesBetween(changelog, from, upto).filter(isDisruptiveAt);
+var mechanicalMigrations = (migrations) => migrations.filter((found) => isMechanical(found.migration));
+var migrationsBetween = (changelog, from, upto) => disruptiveBetween(changelog, from, upto).map(({ change: change2, version }) => {
+  const found = {
+    migration: change2.migration,
+    symbols: change2.symbols,
+    version
+  };
+  return found;
+});
+var symbolsDisturbedBetween = (changelog, from, upto) => new Set(disruptiveBetween(changelog, from, upto).flatMap(({ change: change2 }) => change2.symbols));
+
+// src/tarball.ts
+var TAR_BLOCK = 512;
+var NAME_LENGTH = 100;
+var SIZE_OFFSET = 124;
+var SIZE_LENGTH = 12;
+var TYPE_OFFSET = 156;
+var PREFIX_OFFSET = 345;
+var PREFIX_LENGTH = 155;
+var OCTAL = 8;
+var KIBIBYTE = 1024;
+var MEBIBYTE = KIBIBYTE * KIBIBYTE;
+var DEFAULT_FILE_MEBIBYTES = 4;
+var DEFAULT_TOTAL_MEBIBYTES = 64;
+var DEFAULT_FILE_BYTES = DEFAULT_FILE_MEBIBYTES * MEBIBYTE;
+var DEFAULT_TOTAL_BYTES = DEFAULT_TOTAL_MEBIBYTES * MEBIBYTE;
+var decoder = new TextDecoder;
+var cString = (bytes) => {
+  const end = bytes.indexOf(0);
+  return decoder.decode(end < 0 ? bytes : bytes.subarray(0, end)).trim();
+};
+var asText = (bytes) => decoder.decode(bytes);
+var readTar = (archive, keep, limits = {}) => {
+  const maxFile = limits.maxFileBytes ?? DEFAULT_FILE_BYTES;
+  const maxTotal = limits.maxTotalBytes ?? DEFAULT_TOTAL_BYTES;
+  const files = new Map;
+  let offset = 0;
+  let total = 0;
+  while (offset + TAR_BLOCK <= archive.length) {
+    const header = archive.subarray(offset, offset + TAR_BLOCK);
+    const name = cString(header.subarray(0, NAME_LENGTH));
+    if (name === "")
+      break;
+    const prefix = cString(header.subarray(PREFIX_OFFSET, PREFIX_OFFSET + PREFIX_LENGTH));
+    const size = Number.parseInt(cString(header.subarray(SIZE_OFFSET, SIZE_OFFSET + SIZE_LENGTH)), OCTAL);
+    if (!Number.isSafeInteger(size) || size < 0)
+      break;
+    const kind = String.fromCharCode(header[TYPE_OFFSET] ?? 0);
+    const start = offset + TAR_BLOCK;
+    const path = (prefix === "" ? name : `${prefix}/${name}`).replace(/^package\//u, "");
+    const plain = kind === "0" || kind === "\x00";
+    const wanted = plain && size <= maxFile && keep(path);
+    total += wanted ? size : 0;
+    if (total > maxTotal)
+      break;
+    if (wanted)
+      files.set(path, archive.subarray(start, start + size));
+    offset = start + Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+  }
+  return files;
+};
+
+// 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) => {
+  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)
+      continue;
+    add(name, normalize(source.slice(match.index, declarationEnd(source, match.index + match[0].length, BODIED.has(keyword ?? "")))));
+  }
+  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) => {
+  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);
+    }
+  return surface;
+};
+var SHAPE = {
+  members: "members",
+  parameters: "parameters",
+  types: "types",
+  unknown: "unknown"
+};
+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 "";
+};
+var membersOf = (declaration) => {
+  const opened = declaration.indexOf("{");
+  if (opened < 0)
+    return new Set;
+  const members = new Set;
+  let depth = 0;
+  let segment = "";
+  const take = () => {
+    const [, name] = MEMBER.exec(segment.trim()) ?? [];
+    if (name !== undefined)
+      members.add(name);
+    segment = "";
+  };
+  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();
+  return members;
+};
+var sameNames = (left, right) => left.size === right.size && [...left].every((name) => right.has(name));
+var changeShape = (change2) => {
+  if (isStub(change2.before) !== isStub(change2.after))
+    return SHAPE.unknown;
+  if (parametersOf(change2.before) !== parametersOf(change2.after))
+    return SHAPE.parameters;
+  if (!sameNames(membersOf(change2.before), membersOf(change2.after)))
+    return SHAPE.members;
+  return SHAPE.types;
+};
+var diffSurface = (before, after) => {
+  const removed = [];
+  const changed = [];
+  for (const [name, declaration] of before) {
+    const now = after.get(name);
+    if (now === undefined)
+      removed.push(name);
+    else if (now !== declaration)
+      changed.push({
+        after: now,
+        before: declaration,
+        name,
+        shape: changeShape({ after: now, before: declaration })
+      });
+  }
+  return {
+    added: [...after.keys()].filter((name) => !before.has(name)),
+    changed,
+    removed
+  };
+};
+var notable = (diff) => diff.changed.filter((change2) => change2.shape === "parameters" || change2.shape === "members");
+
+// src/entries.ts
+var loadEntry = async (path) => {
+  try {
+    const module = await import(pathToFileURL(path).href);
+    const exported = typeof module === "object" && module !== null && "default" in module ? module.default : undefined;
+    const read = { exported };
+    return read;
+  } catch (error) {
+    const failed = {
+      failure: error instanceof Error ? error.message : String(error)
+    };
+    return failed;
+  }
+};
+var ENTRY = /\.[cm]?ts$/u;
+var builtSurface = async (packageRoot, out = "dist") => {
+  const root = join(packageRoot, out);
+  const sources = [];
+  const walk = async (directory) => {
+    const found = await readdir(directory, { withFileTypes: true }).catch(() => []);
+    await Promise.all(found.map(async (entry) => {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory())
+        return walk(path);
+      if (!entry.name.endsWith(".d.ts"))
+        return;
+      sources.push(await readFile(path, "utf8").catch(() => ""));
+      return;
+    }));
+  };
+  await walk(root);
+  return sources.length === 0 ? undefined : surfaceOfFiles(sources);
+};
+var changelogPaths = (packageRoot) => ({
+  history: join(packageRoot, "changelog", "history.md"),
+  json: join(packageRoot, CHANGELOG_FILE),
+  markdown: join(packageRoot, CHANGELOG_MARKDOWN),
+  unreleased: join(packageRoot, UNRELEASED_DIRECTORY)
+});
+var loadUnreleased = async (packageRoot) => {
+  const directory = join(packageRoot, UNRELEASED_DIRECTORY);
+  const names = await readdir(directory).catch(() => []);
+  const entries = [];
+  const problems = [];
+  for (const name of names.filter((file) => ENTRY.test(file)).sort()) {
+    const file = join(UNRELEASED_DIRECTORY, name);
+    const loaded = await loadEntry(join(directory, name));
+    if (loaded.failure !== undefined)
+      problems.push(`${file}: ${loaded.failure}`);
+    const checked = loaded.failure === undefined ? validateChange(loaded.exported, file) : undefined;
+    if (checked?.problems)
+      problems.push(...checked.problems);
+    if (checked?.change !== undefined)
+      entries.push({ change: checked.change, file });
+  }
+  return { entries, problems };
+};
+var readJsonFile = async (path) => {
+  const source = await readFile(path, "utf8").catch(() => {
+    return;
+  });
+  if (source === undefined)
+    return;
+  try {
+    const document = JSON.parse(source);
+    return document;
+  } catch {
+    return;
+  }
+};
+// src/reconcile.ts
+var describeReconciliation = (found) => {
+  const lines = [];
+  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`);
+  for (const name of found.unknownSymbols)
+    lines.push(`an entry names \`${name}\`, which this package does not export`);
+  return lines;
+};
+var reconcile = (input) => {
+  const announced = new Set(input.changes.filter(isDisruptive).flatMap((change2) => [...change2.symbols]));
+  const unannounced = [
+    ...input.diff.removed.map((name) => ({ kind: "removed", name })),
+    ...notable(input.diff).map((change2) => ({
+      kind: change2.shape === "parameters" ? "parameters" : "members",
+      name: change2.name
+    }))
+  ].filter((entry) => !announced.has(entry.name));
+  const unknownSymbols = [
+    ...new Set(input.changes.flatMap((change2) => [...change2.symbols ?? []]).filter((name) => !input.known.has(name)))
+  ];
+  return { unannounced, unknownSymbols };
+};
+// src/registry.ts
+import { gunzipSync } from "zlib";
+var ABBREVIATED = "application/vnd.npm.install-v1+json";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var readPackument = (body) => {
+  if (!isRecord2(body) || !isRecord2(body.versions))
+    return;
+  const tarballs = {};
+  for (const [version, entry] of Object.entries(body.versions)) {
+    if (!isRecord2(entry) || !isRecord2(entry.dist))
+      continue;
+    const { tarball } = entry.dist;
+    if (typeof tarball === "string")
+      tarballs[version] = tarball;
+  }
+  const tags = body["dist-tags"];
+  const latest = isRecord2(tags) ? tags.latest : undefined;
+  return {
+    ...typeof latest === "string" ? { latest } : {},
+    published: Object.keys(body.versions),
+    tarballs
+  };
+};
+var packageArchive = async (name, version, options = {}) => {
+  const call = options.fetch ?? fetch;
+  const versions = await packageVersions(name, options);
+  const url = versions?.tarballs[version];
+  if (url === undefined)
+    return;
+  try {
+    const response = await call(url);
+    if (!response.ok)
+      return;
+    return new Uint8Array(gunzipSync(new Uint8Array(await response.arrayBuffer())));
+  } catch {
+    return;
+  }
+};
+var packageVersions = async (name, options = {}) => {
+  const call = options.fetch ?? fetch;
+  try {
+    const response = await call(`${options.registry ?? DEFAULT_REGISTRY}/${name.replace("/", "%2f")}`, { headers: { accept: ABBREVIATED } });
+    if (!response.ok)
+      return;
+    return readPackument(await response.json());
+  } catch {
+    return;
+  }
+};
+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);
+  if (!file)
+    return;
+  try {
+    return parseChangelog(JSON.parse(asText(file))).changelog;
+  } catch {
+    return;
+  }
+};
+var publishedSurface = async (name, version, options = {}) => {
+  const archive = await packageArchive(name, version, options);
+  return archive === undefined ? undefined : surfaceOfArchive(archive);
+};
+// src/write.ts
+var HEADING = {
+  added: "Added",
+  breaking: "Breaking",
+  changed: "Changed",
+  deprecated: "Deprecated",
+  fixed: "Fixed",
+  internal: "Internal",
+  removed: "Removed",
+  security: "Security"
+};
+var ORDER = [
+  "breaking",
+  "removed",
+  "deprecated",
+  "security",
+  "added",
+  "changed",
+  "fixed",
+  "internal"
+];
+var migrationLine = (migration) => {
+  if ("rename" in migration)
+    return `Rename \`${migration.rename.from}\` to \`${migration.rename.to}\`.`;
+  if ("moved" in migration)
+    return `Import \`${migration.moved.symbol}\` from \`${migration.moved.to}\` instead of \`${migration.moved.from}\`.`;
+  if ("resubpath" in migration)
+    return `Import from \`${migration.resubpath.to}\` instead of \`${migration.resubpath.from}\`.`;
+  return migration.instruction;
+};
+var renderChange = (change2) => {
+  const symbols = change2.symbols && change2.symbols.length > 0 ? ` (${change2.symbols.map((name) => `\`${name}\``).join(", ")})` : "";
+  const lines = [`- **${change2.summary}**${symbols}`];
+  if (change2.detail !== undefined)
+    lines.push(`  ${change2.detail}`);
+  if (isDisruptive(change2)) {
+    lines.push(`  _Migration:_ ${change2.migration.instruction}`);
+    const mechanical = migrationLine(change2.migration);
+    if (mechanical !== change2.migration.instruction)
+      lines.push(`  _Applied automatically:_ ${mechanical}`);
+  }
+  if (change2.reference !== undefined)
+    lines.push(`  See ${change2.reference}.`);
+  return lines.join(`
+`);
+};
+var renderRelease = (release) => {
+  const sections = ORDER.map((kind) => {
+    const changes = release.changes.filter((entry) => entry.kind === kind);
+    if (changes.length === 0)
+      return null;
+    return [`### ${HEADING[kind]}`, "", ...changes.map(renderChange)].join(`
+`);
+  }).filter((section) => section !== null);
+  return [
+    `## ${release.version} \u2014 ${release.date}`,
+    ...release.note === undefined ? [] : ["", release.note],
+    "",
+    sections.join(`
+
+`)
+  ].join(`
+`);
+};
+var renderChangelogJson = (changelog) => `${JSON.stringify({
+  contract: CHANGELOG_CONTRACT,
+  name: changelog.name,
+  releases: [...changelog.releases].sort((left, right) => compareVersions(right.version, left.version)).map((release) => ({
+    changes: release.changes.map((change2) => ({
+      ...change2.detail === undefined ? {} : { detail: change2.detail },
+      kind: change2.kind,
+      ...isDisruptive(change2) ? { migration: change2.migration } : {},
+      ...change2.reference === undefined ? {} : { reference: change2.reference },
+      summary: change2.summary,
+      ...change2.symbols && change2.symbols.length > 0 ? { symbols: change2.symbols } : {}
+    })),
+    date: release.date,
+    ...release.note === undefined ? {} : { note: release.note },
+    version: release.version
+  }))
+}, null, "\t")}
+`;
+var renderMarkdown = (changelog, options = {}) => {
+  const releases = [...changelog.releases].sort((left, right) => compareVersions(right.version, left.version));
+  const head = [
+    "# Changelog",
+    "",
+    `All notable changes to \`${changelog.name}\`.`,
+    "",
+    "This file is generated by `absolute-changelog` from the entries in",
+    "`changelog/`. Edit an entry, not this file \u2014 and add new ones under",
+    "`changelog/unreleased/`."
+  ].join(`
+`);
+  const body = releases.map(renderRelease).join(`
+
+`);
+  const tail = options.history === undefined || options.history.trim() === "" ? "" : ["---", "", "## Earlier releases", "", options.history.trim()].join(`
+`);
+  return `${[head, body, tail].filter((part) => part !== "").join(`
+
+`)}
+`;
+};
+export {
+  CHANGELOG_CONTRACT,
+  CHANGELOG_FILE,
+  CHANGELOG_MARKDOWN,
+  CHANGE_KINDS,
+  DISRUPTIVE_KINDS,
+  UNRELEASED_DIRECTORY,
+  applyMigration,
+  applyMigrations,
+  asText,
+  builtSurface,
+  change,
+  changeShape,
+  changelogPaths,
+  changesBetween,
+  compareVersions,
+  describeReconciliation,
+  diffSurface,
+  disruptiveBetween,
+  exportedDeclarations,
+  isDisruptive,
+  isMechanical,
+  isPrerelease,
+  loadUnreleased,
+  manual,
+  mechanicalMigrations,
+  migrationsBetween,
+  moved,
+  nextVersion,
+  notable,
+  packageArchive,
+  packageVersions,
+  parseChangelog,
+  parseVersion,
+  publishedChangelog,
+  publishedSurface,
+  readJsonFile,
+  readTar,
+  reconcile,
+  releaseKindFor,
+  releasesBetween,
+  renamed,
+  renderChangelogJson,
+  renderMarkdown,
+  surfaceOfArchive,
+  surfaceOfFiles,
+  symbolsDisturbedBetween,
+  validateChange
+};
+
+//# debugId=24AC404EA4C9D1DD64756E2164756E21
+//# sourceMappingURL=index.js.map