@arcgis/api-extractor 5.0.0-next.98 → 5.0.0

package/dist/cli-7PX_wNxb.js

@@ -0,0 +1,34 @@
+import { writeFile as r, readFile as d } from "node:fs/promises";
+import { diffApiJson as m } from "./diff/diffApiJson.js";
+async function k({
+  oldPath: t,
+  newPath: i,
+  outputPath: o,
+  docsUrlPrefix: e
+}) {
+  const c = f(t), w = f(i), p = await c, l = await w, n = m(p, l);
+  if (typeof o == "string")
+    if (o.endsWith(".md")) {
+      const { apiDiffToMarkdown: s } = await import("./diff/apiDiffToMarkdown.js"), a = s(n, e);
+      await r(o, a, "utf-8");
+    } else
+      await r(o, JSON.stringify(n, null, 2), "utf-8");
+  else {
+    const { apiDiffToMarkdown: s } = await import("./diff/apiDiffToMarkdown.js"), a = s(n, e);
+    console.log(a);
+  }
+}
+async function f(t) {
+  if (t.startsWith("http://") || t.startsWith("https://")) {
+    const i = await fetch(t);
+    if (!i.ok)
+      throw new Error(`Failed to fetch api.json: ${i.statusText}`);
+    return await i.json();
+  } else {
+    const i = await d(t, "utf-8");
+    return JSON.parse(i);
+  }
+}
+export {
+  k as diffApiCli
+};

package/dist/cli.js

@@ -1,14 +1,57 @@
 #!/usr/bin/env node
-import { Command as i } from "@commander-js/extra-typings";
-const e = new i();
-e.name("api-extractor").description("Extract public API from a TypeScript project to produce .d.ts types and api.json docs");
-e.command("diff-types").description("Generate a types diff summary .md file").requiredOption("--original-dts <originalTypings>", "Path to the original types folder").requiredOption("--new-dts <newTypings>", "Path to the new types folder").option("--output-md <outputMd>", "Path to the output markdown file", "types-diff.md").option("--no-truncate", "Do not truncate output if it is longer than 1000 lines", !0).action(async (t) => {
-  const { diffTypes: o } = await import("./diffTypes/index.js");
-  await o({
+import { Command as c } from "@commander-js/extra-typings";
+const o = new c();
+o.name("api-extractor").description("Extract public API from a TypeScript project to produce .d.ts types and api.json docs");
+o.command("run").description("Generate .d.ts types and api.json API reference for a project").option("--cwd <arcgis-js-api>", "Path to the root of the project (default: process.cwd())").option("--dts <outputDirectory>", "Destination for the .d.ts files (example: dist/)").option("--api-json <outputLocation>", "Destination for the api.json file (example: dist/docs/api.json)").option("--environment <environment>", "Environment to run in (production or development) (default: production)").option("--type-check", "Run full type checking before the extraction (default: false)").option("--verify", "Run type checker on the emitted types (default: false)").option("--watch", "Watch for file changes and re-run the extraction automatically", !1).option(
+  "--config <configPath>",
+  "Path to the ./api-extractor.config.ts file. The provided path will be used as is in import(). The config file should export a `config` object of type ApiExtractorConfig (default: api-extractor.config.ts in the cwd)"
+).option(
+  "--silence-broken-links",
+  "(deprecated) Do not emit errors for broken @links in JSDoc comments. Temporary option for migration period (default: false)"
+).action(async (t) => {
+  const { loadApiExtractorConfig: e, mergeApiExtractorConfigs: n } = await import("./extractor/config.js"), a = await e(t.cwd, t.config), r = n(a, {
+    context: {
+      dtsEmitPath: t.dts,
+      apiJsonEmitPath: t.apiJson,
+      environment: t.environment === "development" ? "development" : void 0,
+      cwd: t.cwd
+    },
+    types: {
+      fullTypeCheck: t.typeCheck
+    },
+    verify: {
+      typeCheckTypes: t.verify,
+      detectBrokenLinks: t.silenceBrokenLinks === !0 ? !1 : void 0
+    }
+  }), { ApiExtractor: p } = await import("./extractor/ApiExtractor.js"), i = new p(r);
+  t.watch ? await i.watch() : await i.run();
+});
+o.command("diff").description("Produce a diff of two api.json files").requiredOption(
+  "--old <string>",
+  "URL or file path to the old api.json file. Example: https://unpkg.com/@arcgis/map-components@latest/dist/docs/api.json"
+).requiredOption(
+  "--new <string>",
+  "URL or file path to the new api.json file. Example: ./packages/map-packages/map-components/dist/docs/api.json"
+).option("--output <path>", "Path to the output .md or .json file. If not provided, will print markdown to console").option(
+  "--docs-url-prefix <string>",
+  "Base URL for documentation links. Used only if output format is Markdown",
+  "https://developers.arcgis.com/javascript/latest/references/core/"
+).action(async (t) => {
+  const { diffApiCli: e } = await import("./cli-7PX_wNxb.js");
+  await e({
+    oldPath: t.old,
+    newPath: t.new,
+    outputPath: t.output,
+    docsUrlPrefix: t.docsUrlPrefix
+  });
+});
+o.command("diff-types").description("Generate a types diff summary .md file").requiredOption("--original-dts <originalTypings>", "Path to the original types folder").requiredOption("--new-dts <newTypings>", "Path to the new types folder").option("--output-md <outputMd>", "Path to the output markdown file", "types-diff.md").option("--no-truncate", "Do not truncate output if it is longer than 1000 lines", !0).action(async (t) => {
+  const { diffTypes: e } = await import("./diffTypes/index.js");
+  await e({
     originalDtsPath: t.originalDts,
     newDtsPath: t.newDts,
     outputMdPath: t.outputMd,
     truncate: t.truncate
   });
 });
-e.parse();
+o.parse();

package/dist/compilerHints.d.ts

@@ -0,0 +1,62 @@
+/**
+ * We try to keep public and private types close to keep the API more
+ * maintainable. However, occasionally we must diverge to hide some private
+ * details from the public API.
+ *
+ * Use this type helper when public TypeScript type must diverge from the
+ * private type.
+ *
+ * @example
+ * ```ts
+ * type ActionType = PublicApiNarrowType<
+ *   "create" | "update" | "delete",
+ *   "create" | "delete"
+ * >;
+ * ```
+ *
+ * In private types, the 1st type parameter will be used for type checking,
+ * making the effective type `"create" | "update" | "delete"`.
+ *
+ * But in public `.d.ts` and public docs, the above will appear like this:
+ *
+ * ```ts
+ * type ActionType = "create" | "delete";
+ * ```
+ *
+ * Remember that properties without `public` tag are not publicly exposed.
+ * Thus, in practice, `PublicApiNarrowType` is most commonly needed to hide
+ * private union members.
+ *
+ * To ensure public type does not get out of date, `PublicApiNarrowType`
+ * requires that the public type extends the private type (or in other words, a
+ * subset of the private type). If that restriction is too tight, use
+ * `PublicApiRelaxType` instead.
+ */
+export type PublicApiNarrowType<PrivateType, _PublicType extends PrivateType> = PrivateType;
+
+/**
+ * Most of the time, when the public type must diverge from the private type,
+ * the public type is a subset of the private type - in such cases use
+ * `PublicApiNarrowType`.
+ *
+ * Occasionally, the public type may need to be a superset of the private type
+ * or even an unrelated type. For those cases, use `PublicApiRelaxType`.
+ *
+ * Keep usages of `PublicApiRelaxType` at minimum as it disables type
+ * checking between public and private types.
+ *
+ * @example
+ * ```ts
+ * type EditableLayers = FeatureLayer | ...;
+ * class MyClass {
+ *   // Layer is a superset of EditableLayers, not subset,
+ *   // so we must use PublicApiRelaxType.
+ *   layer: PublicApiRelaxType<EditableLayers, Layer>;
+ *
+ *   // StrictNumberType is a branded type that is incompatible
+ *   // with regular number type.
+ *   jobId: PublicApiRelaxType<StrictNumberType<"JobId">, number>;
+ * }
+ * ```
+ */
+export type PublicApiRelaxType<PrivateType, _PublicType> = PrivateType;

package/dist/diff/apiDiffToMarkdown.d.ts

@@ -0,0 +1,9 @@
+import type { ApiDiff } from "./types.js";
+
+/**
+ * Render an ApiDiff to a markdown nested lists tree.
+ *
+ * @param apiJson
+ * @param docsUrlPrefix
+ */
+export function apiDiffToMarkdown(apiJson: Pick<ApiDiff, "modules">, docsUrlPrefix: string): string;

package/dist/diff/apiDiffToMarkdown.js

@@ -0,0 +1,140 @@
+import { buildViewUrl as T } from "../extractor/processing/links.js";
+function K({ modules: e }, t) {
+  const o = {
+    children: /* @__PURE__ */ new Map(),
+    members: []
+  };
+  for (let n = 0; n < e.length; ++n) {
+    const s = e[n], w = s.path.split("/");
+    let y = w;
+    const M = w.at(-1);
+    s.declarations.length === 1 && s.declarations[0].name === M && (y = w.slice(0, -1));
+    let U = o;
+    for (const g of y)
+      U = N(U, g);
+    for (let g = 0; g < s.declarations.length; ++g) {
+      const h = s.declarations[g], S = B(h), O = h.removed === !0 ? void 0 : $(t, s.path, h, void 0), k = j(h), x = { label: S, viewUrl: O, change: k }, d = h, m = [];
+      if (d.members !== void 0)
+        for (let l = 0; l < d.members.length; ++l) {
+          const a = d.members[l], f = p(a.kind, a);
+          if (f === void 0)
+            continue;
+          const v = F(a), r = a.removed === !0 ? void 0 : $(
+            t,
+            s.path,
+            h,
+            "name" in a ? a.name : `${h.name}Properties`
+          );
+          m.push({ label: v, viewUrl: r, change: f });
+        }
+      if (d.events !== void 0)
+        for (let l = 0; l < d.events.length; ++l) {
+          const a = d.events[l], f = p("event", a);
+          if (f === void 0)
+            continue;
+          const v = a.removed === !0 ? void 0 : $(t, s.path, h, `event-${a.name}`);
+          m.push({ label: `@${a.name}`, viewUrl: v, change: f });
+        }
+      if (typeof d.tagName == "string") {
+        const l = d.slots, a = d.cssParts, f = d.cssProperties, v = d.cssStates;
+        if (l !== void 0)
+          for (let r = 0; r < l.length; ++r) {
+            const i = l[r], u = p("slot", i);
+            if (u === void 0)
+              continue;
+            const b = i.removed === !0 ? void 0 : $(t, s.path, h, `slot-${i.name}`);
+            m.push({ label: i.name, viewUrl: b, change: u });
+          }
+        if (a !== void 0)
+          for (let r = 0; r < a.length; ++r) {
+            const i = a[r], u = p("css part", i);
+            if (u === void 0)
+              continue;
+            m.push({ label: i.name, viewUrl: void 0, change: u });
+          }
+        if (f !== void 0)
+          for (let r = 0; r < f.length; ++r) {
+            const i = f[r], u = p("css property", i);
+            if (u === void 0)
+              continue;
+            const b = i.removed === !0 ? void 0 : $(t, s.path, h, i.name);
+            m.push({ label: i.name, viewUrl: b, change: u });
+          }
+        if (v !== void 0)
+          for (let r = 0; r < v.length; ++r) {
+            const i = v[r], u = p("css state", i);
+            if (u === void 0)
+              continue;
+            m.push({ label: i.name, viewUrl: void 0, change: u });
+          }
+      }
+      m.length > 0 ? E(U, x).members.push(...m) : k !== void 0 && U.members.push(x);
+    }
+  }
+  const c = [];
+  for (const n of o.children.values())
+    L(n, "", c);
+  return c.join(`
+`);
+}
+function N(e, t) {
+  const o = e.children.get(t);
+  if (o !== void 0)
+    return o;
+  const c = { name: t, children: /* @__PURE__ */ new Map(), members: [], node: void 0 };
+  return e.children.set(t, c), c;
+}
+function j(e) {
+  const t = e.tagName !== void 0 ? "component" : e.kind === "interface" ? "type declaration" : e.kind;
+  return p(t, e);
+}
+function p(e, t) {
+  const { added: o, removed: c, deprecated: n } = t;
+  if (c) {
+    const s = `**removed** ${e}`;
+    return typeof n == "string" ? `${s} - deprecated ${D(n)}` : s;
+  }
+  if (n)
+    return typeof n == "string" ? `**deprecated** ${e} ${D(n)}` : `**deprecated** ${e}`;
+  if (o)
+    return `**added** ${e}`;
+}
+function B(e) {
+  const t = e.tagName;
+  return typeof t == "string" && t.length > 0 ? t : C(e.name) + (e.kind === "function" ? "()" : "");
+}
+function $(e, t, o, c) {
+  const n = `${e}${t}/`;
+  return T(n, o.kind === "class" ? void 0 : o.name, c);
+}
+function E(e, t) {
+  const o = N(e, t.label);
+  return o.node = t, o;
+}
+function F(e) {
+  return e.kind === "constructor" ? "constructor" : e.kind === "call-signature" ? "call signature" : e.kind === "method" ? `${C(e.name)}()` : C(e.name);
+}
+function C(e) {
+  return e.replace(/[\\\[\]\(\)]/gu, "\\$&");
+}
+function D(e) {
+  return e.split(`
+`)[0];
+}
+function L(e, t, o) {
+  if (e.node) {
+    const n = e.node.viewUrl === void 0 ? e.node.label : `[${e.node.label}](${e.node.viewUrl})`;
+    e.node.change ? o.push(`${t}- ${n} - ${e.node.change}`) : o.push(`${t}- ${n}`);
+  } else
+    o.push(`${t}- ${e.name}/`);
+  const c = `${t}  `;
+  for (const n of e.members) {
+    const s = n.viewUrl === void 0 ? n.label : `[${n.label}](${n.viewUrl})`;
+    n.change ? o.push(`${c}- ${s} - ${n.change}`) : o.push(`${c}- ${s}`);
+  }
+  for (const n of e.children.values())
+    L(n, c, o);
+}
+export {
+  K as apiDiffToMarkdown
+};

package/dist/diff/diffApiJson.d.ts

@@ -1,10 +1,13 @@
-import { ApiJson } from '../apiJson.ts';
-import { ApiDiff } from './types.ts';
+import type { ApiJson, ApiJsonCompiler } from "../apiJson.js";
+import type { ApiDiff } from "./types.js";
+
 /**
+ * @param oldApiJson
+ * @param newApiJson
  * @example
  * ```js
- * import { diffApiJson, fetchApiJsonFromNpm } from "@arcgis/api-extractor/diff";
- * import { readFileSync, writeFileSync } from "node:fs";
+ * import { diffApiJson } from "@arcgis/api-extractor/diff/diffApiJson";
+ * import { fetchApiJsonFromNpm } from "@arcgis/api-extractor/diff/fetchApiJsonFromNpm";
  *
  * // Read -next api.json from file system:
  * const apiJson = JSON.parse(
@@ -20,4 +23,4 @@ import { ApiDiff } from './types.ts';
  * writeFileSync("api-diff.json", JSON.stringify(diff, null, 2));
  * ```
  */
-export declare function diffApiJson(oldApiJson: Pick<ApiJson, "modules">, newApiJson: Pick<ApiJson, "modules">): ApiDiff;
+export function diffApiJson(oldApiJson: Pick<ApiJson, "modules"> & { compiler?: ApiJsonCompiler; }, newApiJson: Pick<ApiJson, "modules"> & { compiler?: ApiJsonCompiler; }): ApiDiff;

package/dist/diff/diffApiJson.js

@@ -0,0 +1,260 @@
+function w(n, s) {
+  if (n.compiler?.name !== "@arcgis/core:manual" || n.compiler?.version !== "4.34")
+    return;
+  const o = {};
+  return n.modules.forEach((e) => {
+    o[e.path] = e;
+  }), {
+    ...s,
+    modules: s.modules.filter((e) => {
+      const r = o[e.path];
+      return e.declarations = e.declarations.filter((a) => {
+        if (a.kind === "mixin")
+          return !1;
+        if (a.kind === "interface") {
+          const i = r?.declarations.find(
+            (d) => d.name === a.name && d.kind === "interface"
+          );
+          return a.members = void 0, i !== void 0;
+        }
+        return !0;
+      }), e.declarations.length > 0;
+    })
+  };
+}
+function A(n) {
+  const s = /* @__PURE__ */ new Set([
+    // Fake class turned into a variable
+    "config",
+    // Wasn't visible directly before due to doc mismatch
+    "identity/IdentityManagerBase",
+    // Fake class turned into a variable
+    "identity/IdentityManager",
+    // Fake class turned into an interface
+    "views/layers/GeoRSSLayerView",
+    "views/layers/GraphicsLayerView",
+    "views/layers/KMLLayerView",
+    "views/layers/VectorTileLayerView",
+    "views/layers/PointCloudLayerView",
+    // ENUM-like objects turned into const variable + interfaces
+    "layers/support/rasterFunctionConstants"
+  ]), o = n.modules.filter((t) => s.has(t.path) ? !1 : (t.declarations = t.declarations.filter((e) => e.kind === "class" ? e.members === void 0 ? !0 : (e.members = e.members.filter((r) => !(r.kind === "constructor" || r.kind === "call-signature" || P.has(r.name))), e.members.length > 0) : !0), t.declarations.length > 0));
+  return { ...n, modules: o };
+}
+const P = /* @__PURE__ */ new Set([
+  // Excluded from api.json inheritance to keep file size in check
+  "addHandles",
+  "hasHandles",
+  "removeHandles",
+  // These are coming from mixins. Exclude them from the diff to reduce noise
+  // compared to more valuable new 5.0 fields.
+  // Added 77 times
+  "emit",
+  // 77
+  "hasEventListener",
+  // 73
+  "fromJSON",
+  // 72
+  "on",
+  // 71
+  "toJSON",
+  // 63
+  "declaredClass",
+  // 63
+  "getAtOrigin",
+  // 63
+  "originOf",
+  // 63
+  "revertAllToOrigin",
+  // 63
+  "revertToOrigin",
+  // 54
+  "clone",
+  // 50
+  "fromPortalItem",
+  // 49
+  "fromArcGISServerUrl",
+  // 28
+  "isFulfilled",
+  // 28
+  "isRejected",
+  // 28
+  "isResolved",
+  // 28
+  "when",
+  // 6
+  "cancelLoad",
+  // 6
+  "loadError",
+  // 6
+  "loadStatus",
+  // 6
+  "loadWarnings"
+]);
+function N(n, s) {
+  const o = w(n, s), t = o ?? s, e = n.compiler?.version.startsWith("4.") === !0 && t.compiler?.version.startsWith("4.") !== !0, r = new Map(
+    n.modules.map((d) => [
+      b(d, e),
+      d
+    ])
+  ), a = [];
+  for (const d of t.modules) {
+    const l = r.get(d.path), m = y(l, d, !0);
+    m !== void 0 && a.push(m), r.delete(d.path);
+  }
+  for (const d of r.values()) {
+    const l = y(
+      void 0,
+      e ? { ...d, path: b(d, e) } : d,
+      !1
+    );
+    l !== void 0 && a.push(l);
+  }
+  const i = { modules: a };
+  return o === void 0 ? i : A(i);
+}
+function b(n, s) {
+  return s ? n.declarations?.[0]?.importPath ?? n.path : n.path;
+}
+function y(n, s, o) {
+  const t = [], e = h(n?.declarations ?? []), r = h(s.declarations ?? []);
+  for (const a of r.values()) {
+    const i = a.at(-1), d = i.tagName, l = d ?? i.name, m = e.get(l);
+    e.delete(l);
+    const g = m === void 0 && !o ? !0 : void 0, f = (
+      // Only mark as deprecated if all overloads are deprecated
+      a.length === 1 || a.every((c) => c.deprecated !== void 0) ? i.deprecated : void 0
+    ), k = !f && m === void 0 && o ? !0 : void 0;
+    if (g || k) {
+      t.push({
+        kind: i.kind,
+        name: i.name,
+        tagName: d,
+        members: void 0,
+        removed: g,
+        added: k,
+        deprecated: f
+      });
+      continue;
+    } else if (!o)
+      continue;
+    if (d !== void 0) {
+      const c = i, u = m?.[0], v = {
+        kind: c.kind,
+        name: c.name,
+        tagName: c.tagName,
+        deprecated: f,
+        added: void 0,
+        removed: void 0,
+        members: M(u?.members, c.members),
+        events: p(u?.events, c.events),
+        slots: p(u?.slots, c.slots),
+        cssParts: p(u?.cssParts, c.cssParts),
+        cssProperties: p(u?.cssProperties, c.cssProperties),
+        cssStates: p(u?.cssStates, c.cssStates)
+      };
+      (f !== void 0 || v.members !== void 0 || v.events !== void 0 || v.slots !== void 0 || v.cssParts !== void 0 || v.cssProperties !== void 0 || v.cssStates !== void 0) && t.push(v);
+    } else if (i.kind === "class" || i.kind === "interface" || i.kind === "mixin") {
+      const c = m?.[0], u = {
+        kind: i.kind,
+        name: i.name,
+        deprecated: f,
+        added: void 0,
+        removed: void 0,
+        members: M(c?.members, i.members),
+        events: "events" in i ? p(c?.events, i.events) : void 0
+      };
+      (f !== void 0 || u.members !== void 0 || u.events !== void 0) && t.push(u);
+    } else f !== void 0 && t.push({
+      kind: i.kind,
+      name: i.name,
+      deprecated: f,
+      added: void 0,
+      removed: void 0
+    });
+  }
+  if (o)
+    for (const [a] of e.values())
+      t.push({
+        kind: a.kind,
+        name: a.name,
+        tagName: a.tagName,
+        members: void 0,
+        removed: !0,
+        added: void 0,
+        deprecated: a.deprecated
+      });
+  if (t.length !== 0)
+    return {
+      path: s.path,
+      declarations: t
+    };
+}
+function h(n) {
+  const s = /* @__PURE__ */ new Map();
+  for (let o = 0; o < n.length; ++o) {
+    const t = n[o], e = t.tagName ?? t.name ?? t.kind, r = s.get(e);
+    x(t.docsTags) || (r === void 0 ? s.set(e, [t]) : r.push(t));
+  }
+  return s;
+}
+function x(n) {
+  if (n !== void 0) {
+    for (let s = 0; s < n.length; ++s)
+      if (n[s].name === "internal")
+        return !0;
+  }
+  return !1;
+}
+function p(n, s) {
+  const o = h(n ?? []), t = [];
+  if (s !== void 0)
+    for (const e of s)
+      o.get(e.name) === void 0 ? t.push({
+        name: e.name,
+        added: !0
+      }) : e.deprecated && t.push({
+        name: e.name,
+        deprecated: e.deprecated
+      }), o.delete(e.name);
+  for (const [e] of o.values())
+    t.push({
+      name: e.name,
+      removed: !0,
+      deprecated: e.deprecated
+    });
+  return t.length ? t : void 0;
+}
+function M(n, s) {
+  const o = h(n ?? []), t = h(s ?? []), e = [];
+  for (const [r, a] of t.entries()) {
+    const i = a.at(-1), d = o.get(r);
+    o.delete(r);
+    const l = (
+      // Only mark as deprecated if all overloads are deprecated
+      a.length === 1 || a.every((g) => g.deprecated !== void 0) ? i.deprecated : void 0
+    ), m = r === "constructor" || r === "call-signature" ? void 0 : r;
+    l ? e.push({
+      kind: i.kind,
+      name: m,
+      deprecated: l
+    }) : d === void 0 && e.push({
+      kind: i.kind,
+      name: m,
+      added: !0
+    });
+  }
+  for (const [r, [a]] of o.entries()) {
+    const i = r === "constructor" || r === "call-signature" ? void 0 : r;
+    e.push({
+      kind: a.kind,
+      name: i,
+      removed: !0,
+      deprecated: a.deprecated
+    });
+  }
+  return e.length ? e : void 0;
+}
+export {
+  N as diffApiJson
+};

package/dist/diff/fetchApiJsonFromNpm.d.ts

@@ -1,7 +1,10 @@
-import { ApiJson } from '../apiJson.ts';
+import type { ApiJson } from "../apiJson.js";
+
 /**
  * Read dist/docs/api.json for a given NPM package.
  *
+ * @param packageName
+ * @param semverVersion
  * @example fetchApiJsonFromNpm("@arcgis/map-components", "latest");
  */
-export declare function fetchApiJsonFromNpm(packageName: string, semverVersion: string): Promise<ApiJson>;
+export function fetchApiJsonFromNpm(packageName: string, semverVersion: string): Promise<ApiJson>;

package/dist/diff/fetchApiJsonFromNpm.js

@@ -0,0 +1,9 @@
+async function a(t, s) {
+  const o = await fetch(`https://unpkg.com/${t}@${s}/dist/docs/api.json`);
+  if (!o.ok)
+    throw new Error(`Failed to fetch api.json: ${o.statusText}`);
+  return await o.json();
+}
+export {
+  a as fetchApiJsonFromNpm
+};