@scalar/cli 2.0.1 → 2.1.0

package/chunks/build.action-LKOILPA6.js

@@ -0,0 +1,108 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  BaseCollections
+} from "./chunk-2BSG2QHO.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import {
+  sdkSchema
+} from "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  docVersionSchema,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/sdk/build.action.ts
+import { select } from "@clack/prompts";
+async function buildAction(opts) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    namespace: namespaceSchema.optional(),
+    version: docVersionSchema.optional()
+  }).safeParse(opts);
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const db = await getDatabaseClient();
+  const client = await apiService();
+  const team = await db.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your SDK. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const sdks = await db.getMany({
+    collectionPath: BaseCollections.Sdks(team.data.uid),
+    query: {
+      namespace
+    },
+    schema: sdkSchema.array()
+  });
+  if (sdks.error) return output.error().title(sdks.message).exit("error");
+  const sdkUid = sdks.data.find((sdk) => sdk.slug === data.slug)?.uid || await select({
+    message: "Please select an SDK to update",
+    options: sdks.data.map((sdk) => ({
+      value: sdk.uid,
+      label: sdk.slug
+    }))
+  });
+  const matchingSdk = sdks.data.find((sdk) => sdk.uid === sdkUid);
+  if (!matchingSdk) {
+    return output.error().title("No SDK found").message("Please provide a valid SDK slug").exit("error");
+  }
+  const version = matchingSdk.versions.find((v) => v.version === data.version)?.version || await select({
+    message: "Please select an SDK version to build",
+    options: matchingSdk.versions.map((version2) => ({
+      value: version2.version,
+      label: `v${version2.version}`
+    }))
+  });
+  const logger = output.info().loader("Creating SDK Build");
+  const response = await client.sdks.build(sdkUid, version);
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, {
+    content: `SDK build kicked off for version v${version}`
+  }).exit("success");
+}
+export {
+  buildAction
+};

package/chunks/chunk-23I5PKZZ.js

@@ -0,0 +1,78 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  isUrl
+} from "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+
+// src/domains/document/helpers/banner.ts
+import as from "ansis";
+var printSpecificationBanner = (result) => {
+  const { version, schema } = result;
+  if (!schema?.info?.title || !version) {
+    return;
+  }
+  const pathsCount = Object.keys(schema.paths ?? {}).length;
+  const operationsCount = Object.values(schema.paths ?? {}).reduce(
+    (acc, path) => acc + Object.keys(path).length,
+    0
+  );
+  output.info().title(
+    `${as.white.bold(schema?.info?.title)} ${as.grey(`(OpenAPI v${version})`)}`
+  ).title(as.grey(`${pathsCount} paths, ${operationsCount} operations`)).print();
+};
+
+// src/domains/document/helpers/imports.ts
+import fs from "node:fs";
+import as2 from "ansis";
+import { load, validate } from "@scalar/openapi-parser";
+var getFileOrUrl = async (input) => {
+  if (isUrl(input)) {
+    const response = await fetch(input);
+    if (!response.ok) {
+      return output.error().title("Failed to fetch from URL.").exit("error");
+    }
+    return await response.text();
+  }
+  if (!fs.existsSync(input)) {
+    return output.error().title("Could not read file.").exit("error");
+  }
+  return fs.readFileSync(input, "utf-8");
+};
+var loadOpenApiFile = async (input) => {
+  const specification = await getFileOrUrl(input);
+  try {
+    const { filesystem } = await load(specification);
+    const result = await validate(filesystem);
+    if (!result.valid) {
+      output.warn().title("File does not match the OpenAPI specification.").print();
+      result.errors?.forEach((error) => {
+        output.warn().title(`${error.error} (${error.path})`).print();
+      });
+      return result;
+    }
+    return result;
+  } catch (error) {
+    output.error().title(error ? as2.red(error.toString()) : "Unknown error.").print();
+    const message = typeof error === "object" && error !== null && "message" in error ? String(error.message) : "Unknown error";
+    return {
+      valid: false,
+      version: void 0,
+      specification: void 0,
+      schema: void 0,
+      errors: [
+        {
+          message,
+          path: []
+        }
+      ]
+    };
+  }
+};
+
+export {
+  printSpecificationBanner,
+  getFileOrUrl,
+  loadOpenApiFile
+};

package/chunks/chunk-2BSG2QHO.js

@@ -0,0 +1,455 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  accessGroupSchema,
+  identityProviderRecordSchema,
+  loginPortalSchema,
+  managedSchema,
+  workspaceSchema
+} from "./chunk-UPUTMFD4.js";
+import {
+  userSchema
+} from "./chunk-B6QZJWCQ.js";
+import {
+  sdkSchema
+} from "./chunk-5BPPGTUU.js";
+import {
+  managedDocSchema,
+  ruleSchema
+} from "./chunk-4QS7SJTG.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  activeDeploymentSchema,
+  emailSchema,
+  entitySchema,
+  nanoidSchema,
+  publishRecordSchema,
+  themeSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports,
+  zod_default
+} from "./chunk-H2WRMLYY.js";
+
+// ../../packages/entities/dist/admins/index.js
+var scalarAdminSchema = entitySchema.extend({
+  email: zod_default.string().email(),
+  name: zod_default.string().min(2).max(100),
+  role: zod_default.enum(["admin", "super-admin"])
+}).meta({ id: "scalar-admin" });
+
+// ../../packages/entities/dist/publish/publish.js
+var headingRecordSchema = external_exports.object({
+  slug: external_exports.string(),
+  name: external_exports.string(),
+  level: external_exports.coerce.number().int(),
+  uid: nanoidSchema,
+  parent: external_exports.string().optional(),
+  isPageTitle: external_exports.boolean().optional()
+}).meta({ id: "heading-record" });
+var publishAssetSchema = external_exports.object({
+  path: external_exports.string(),
+  data: external_exports.string()
+}).meta({ id: "publish-asset" });
+var typesenseConfigSchema = external_exports.object({
+  keyId: external_exports.number(),
+  keyValue: external_exports.string(),
+  collectionName: external_exports.string()
+}).meta({ id: "typesense-config" });
+
+// ../../packages/entities/dist/deploys/deploy.js
+var subpathSchema = external_exports.object({
+  subpath: external_exports.string(),
+  projectUid: external_exports.string(),
+  /**
+   * Present only for sites still served by Typesense. Builds on the jsonl
+   * search backend omit it; federated search fetches `${subpath}/search-entries.jsonl`.
+   */
+  typesenseConfig: typesenseConfigSchema.optional().nullable()
+}).meta({ id: "subpath" });
+var siteDeploySchema = entitySchema.extend({
+  domain: external_exports.string(),
+  teamUid: nanoidSchema,
+  projectUid: nanoidSchema,
+  subpaths: subpathSchema.array().default([])
+}).meta({ id: "site-deploy" });
+var searchConfigResponseSchema = external_exports.object({
+  subpaths: subpathSchema.array()
+}).meta({ id: "search-config-response" });
+
+// ../../packages/entities/dist/user/ban.js
+var bannedUserSchema = entitySchema.extend({
+  email: emailSchema,
+  reason: zod_default.string(),
+  bannedBy: emailSchema
+}).meta({ id: "banned-user" });
+
+// ../../packages/entities/dist/database/collections.js
+var BaseCollections = {
+  Users: "users",
+  ScalarAdmins: "admin-users",
+  SignupMeta: "signup-meta",
+  ExchangeTokens: "exchange-tokens",
+  HostingExchange: "hosting-exchange",
+  HostingLoginTokens: "hosting-login-tokens",
+  HostingOauthStates: "hosting-oauth-states",
+  Passwords: "passwords",
+  SignupOtp: "signup-otp",
+  GithubUsers: "github-users",
+  BitbucketUsers: "bitbucket-users",
+  RefreshTokens: "refresh-tokens",
+  LoginAttempts: "login-attempts",
+  Teams: "team",
+  Deploys: "deploys",
+  SamlStates: "saml-states",
+  SignupData: "signup-data",
+  Projects: (teamUid) => `team/${teamUid}/projects`,
+  GithubProjects: (teamUid) => `team/${teamUid}/projects-github`,
+  DocsProjects: (teamUid) => `team/${teamUid}/docs`,
+  Themes: (teamUid) => `team/${teamUid}/themes`,
+  PublishRecords: (teamUid) => `team/${teamUid}/publish`,
+  ManagedDocs: (teamUid) => `team/${teamUid}/managed-docs`,
+  ManagedSchemas: (teamUid) => `team/${teamUid}/managed-schemas`,
+  Rules: (teamUid) => `team/${teamUid}/rules`,
+  RegistryPublishes: (teamUid) => `team/${teamUid}/registry-publishes`,
+  RegistryGitMigrations: "registry-git-migrations",
+  AccessGroups: (teamUid) => `team/${teamUid}/access-groups`,
+  LoginPortals: (teamUid) => `team/${teamUid}/login-portals`,
+  Sdks: (teamUid) => `team/${teamUid}/sdks`,
+  SdkBuilds: (teamUid) => `team/${teamUid}/sdk-builds`,
+  SdkBuildLogs: (teamUid) => `team/${teamUid}/sdk-build-logs`,
+  PersonalTokens: (userUid) => `user/${userUid}/personal-tokens`,
+  IdentityProviders: (teamUid) => `team/${teamUid}/identity-providers`,
+  Workspaces: (teamUid) => `team/${teamUid}/workspaces`,
+  OauthStates: "oauth-states",
+  Waitlist: "waitlist",
+  BannedUsers: "banned-users"
+};
+
+// ../../packages/entities/dist/database/edge-cache.js
+var requiredUid = { uid: nanoidSchema };
+var entityExtension = {
+  ...requiredUid,
+  _path: external_exports.string(),
+  _registryPath: external_exports.string().default("")
+};
+var registryRequiredFields = {
+  uid: true,
+  title: true,
+  slug: true,
+  namespace: true,
+  loginPortalUid: true,
+  isPrivate: true,
+  accessGroups: true
+};
+function generateRegistryPath(entity) {
+  entity._registryPath = `${entity.namespace}/${entity.slug}`;
+  return entity;
+}
+function teamUidFromPath(path) {
+  return path.split("/").at(1) ?? "";
+}
+var edgeCacheDeploySchema = siteDeploySchema.extend(requiredUid);
+var edgeCacheProjectSchema = external_exports.object({
+  ...requiredUid,
+  loginPortalUid: external_exports.string().default(""),
+  accessGroups: external_exports.array(external_exports.string()).default([]),
+  identityProviders: external_exports.string().array().default([]),
+  isPrivate: external_exports.boolean().default(false),
+  /**
+   * The customer's docs-analytics opt-out. It defaults to true, so a cache
+   * that omits the field silently opts an opted-out customer back in — the
+   * hosting proxy projects it on every project collection for this reason.
+   */
+  analyticsEnabled: external_exports.boolean().default(true),
+  activeDeployment: activeDeploymentSchema.nullable().optional(),
+  _path: external_exports.string()
+});
+var edgeCacheGithubProjectSchema = edgeCacheProjectSchema;
+var edgeCacheDocsProjectSchema = edgeCacheProjectSchema;
+var PROJECT_TABLE = "project";
+var edgeCachePublishRecordSchema = publishRecordSchema.pick({ uid: true, projectUid: true, agentToken: true }).extend(requiredUid).transform(({ uid, projectUid, agentToken }) => ({
+  uid,
+  projectUid,
+  agentToken,
+  _publishPath: `${uid.toLowerCase()}/${projectUid}`
+}));
+var edgeCacheApiSchema = managedDocSchema.pick({
+  ...registryRequiredFields,
+  theme: true,
+  version: true,
+  versions: true,
+  agentEnabled: true
+}).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheSchemaSchema = managedSchema.pick({ ...registryRequiredFields, version: true, versions: true }).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheRuleSchema = ruleSchema.pick(registryRequiredFields).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheSdkSchema = sdkSchema.pick({ ...registryRequiredFields, versions: true, targets: true }).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheWorkspaceSchema = workspaceSchema.pick({ ...registryRequiredFields, version: true, versions: true }).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheTeamSchema = teamSchema.pick({
+  uid: true,
+  users: true,
+  externalAccess: true
+}).extend(requiredUid);
+var edgeCacheUserSchema = userSchema.pick({
+  uid: true,
+  email: true
+}).extend(requiredUid);
+var edgeCacheLoginPortalSchema = loginPortalSchema.extend(requiredUid);
+var edgeCacheAccessGroupSchema = accessGroupSchema.extend(requiredUid);
+var edgeCacheThemeSchema = themeSchema.pick({ uid: true, theme: true, slug: true }).extend({ ...requiredUid, _path: external_exports.string() });
+var edgeCacheIdentityProviderSchema = identityProviderRecordSchema.extend({ _path: external_exports.string() }).pick({
+  uid: true,
+  name: true,
+  provider: true,
+  consumerOnly: true,
+  _path: true
+}).extend(requiredUid).transform(({ uid, name, provider, consumerOnly, _path }) => ({
+  uid,
+  name,
+  provider,
+  consumerOnly,
+  teamUid: teamUidFromPath(_path),
+  _path
+}));
+var SAFE_SQL_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSafeIdentifier(value, context) {
+  if (!SAFE_SQL_IDENTIFIER.test(value)) {
+    throw new Error(`Unsafe SQL identifier for edge-cache ${context}: ${JSON.stringify(value)}`);
+  }
+}
+function defineCollection(config) {
+  assertSafeIdentifier(config.tableName, `tableName "${config.tableName}"`);
+  for (const field of config.indexFields) {
+    assertSafeIdentifier(field, `indexField "${field}" on "${config.tableName}"`);
+  }
+  if (config.source !== void 0) {
+    assertSafeIdentifier(config.source, `source "${config.source}" on "${config.tableName}"`);
+  }
+  return config;
+}
+var edgeCacheCollections = {
+  deploy: defineCollection({
+    schema: edgeCacheDeploySchema,
+    indexFields: ["domain"],
+    tableName: "deploy",
+    mongoCollection: BaseCollections.Deploys
+  }),
+  project: defineCollection({
+    schema: edgeCacheProjectSchema,
+    indexFields: [],
+    tableName: PROJECT_TABLE,
+    mongoCollection: BaseCollections.Projects,
+    source: "project",
+    projection: {
+      uid: 1,
+      loginPortalUid: 1,
+      accessGroups: 1,
+      identityProviders: 1,
+      isPrivate: 1,
+      analyticsEnabled: 1,
+      activeDeployment: 1,
+      _path: 1
+    }
+  }),
+  githubProject: defineCollection({
+    schema: edgeCacheGithubProjectSchema,
+    indexFields: [],
+    tableName: PROJECT_TABLE,
+    mongoCollection: BaseCollections.GithubProjects,
+    source: "github",
+    projection: {
+      uid: 1,
+      loginPortalUid: 1,
+      accessGroups: 1,
+      identityProviders: 1,
+      isPrivate: 1,
+      analyticsEnabled: 1,
+      activeDeployment: 1,
+      _path: 1
+    }
+  }),
+  docsProject: defineCollection({
+    schema: edgeCacheDocsProjectSchema,
+    indexFields: [],
+    tableName: PROJECT_TABLE,
+    mongoCollection: BaseCollections.DocsProjects,
+    source: "docs",
+    projection: {
+      uid: 1,
+      loginPortalUid: 1,
+      accessGroups: 1,
+      identityProviders: 1,
+      isPrivate: 1,
+      analyticsEnabled: 1,
+      activeDeployment: 1,
+      _path: 1
+    }
+  }),
+  publishRecord: defineCollection({
+    schema: edgeCachePublishRecordSchema,
+    indexFields: ["_publishPath"],
+    tableName: "publishRecord",
+    mongoCollection: BaseCollections.PublishRecords,
+    projection: { uid: 1, projectUid: 1, agentToken: 1 }
+  }),
+  api: defineCollection({
+    schema: edgeCacheApiSchema,
+    indexFields: ["_registryPath"],
+    tableName: "api",
+    mongoCollection: BaseCollections.ManagedDocs,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      theme: 1,
+      _path: 1,
+      _registryPath: 1,
+      version: 1,
+      versions: 1,
+      agentEnabled: 1
+    }
+  }),
+  schema: defineCollection({
+    schema: edgeCacheSchemaSchema,
+    indexFields: ["_registryPath"],
+    tableName: "schema",
+    mongoCollection: BaseCollections.ManagedSchemas,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      version: 1,
+      versions: 1,
+      _path: 1,
+      _registryPath: 1
+    }
+  }),
+  rule: defineCollection({
+    schema: edgeCacheRuleSchema,
+    indexFields: ["_registryPath"],
+    tableName: "rule",
+    mongoCollection: BaseCollections.Rules,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      _path: 1,
+      _registryPath: 1
+    }
+  }),
+  sdk: defineCollection({
+    schema: edgeCacheSdkSchema,
+    indexFields: ["_registryPath"],
+    tableName: "sdk",
+    mongoCollection: BaseCollections.Sdks,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      versions: 1,
+      targets: 1,
+      _path: 1,
+      _registryPath: 1
+    }
+  }),
+  workspace: defineCollection({
+    schema: edgeCacheWorkspaceSchema,
+    indexFields: ["_registryPath"],
+    tableName: "workspace",
+    mongoCollection: BaseCollections.Workspaces,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      version: 1,
+      versions: 1,
+      _registryPath: 1,
+      _path: 1
+    }
+  }),
+  team: defineCollection({
+    schema: edgeCacheTeamSchema,
+    indexFields: [],
+    tableName: "team",
+    mongoCollection: BaseCollections.Teams,
+    projection: { uid: 1, users: 1, externalAccess: 1 }
+  }),
+  user: defineCollection({
+    schema: edgeCacheUserSchema,
+    indexFields: ["email"],
+    tableName: "user",
+    mongoCollection: BaseCollections.Users,
+    projection: { uid: 1, email: 1 }
+  }),
+  loginPortal: defineCollection({
+    schema: edgeCacheLoginPortalSchema,
+    indexFields: [],
+    tableName: "loginPortal",
+    mongoCollection: BaseCollections.LoginPortals
+  }),
+  accessGroup: defineCollection({
+    schema: edgeCacheAccessGroupSchema,
+    indexFields: [],
+    tableName: "accessGroup",
+    mongoCollection: BaseCollections.AccessGroups
+  }),
+  theme: defineCollection({
+    schema: edgeCacheThemeSchema,
+    indexFields: [],
+    tableName: "theme",
+    mongoCollection: BaseCollections.Themes,
+    projection: { uid: 1, theme: 1, slug: 1, _path: 1 }
+  }),
+  identityProvider: defineCollection({
+    schema: edgeCacheIdentityProviderSchema,
+    indexFields: ["teamUid"],
+    tableName: "identityProvider",
+    mongoCollection: BaseCollections.IdentityProviders,
+    projection: { uid: 1, name: 1, provider: 1, consumerOnly: 1, _path: 1 }
+  })
+};
+var sharedTables = new Set(Object.values(edgeCacheCollections).map((config) => config.tableName).filter((table, index, all) => all.indexOf(table) !== index));
+for (const [key, config] of Object.entries(edgeCacheCollections)) {
+  const shared = sharedTables.has(config.tableName);
+  if (shared && !config.source) {
+    throw new Error(`Edge-cache collection "${key}" shares table "${config.tableName}" but declares no source.`);
+  }
+  if (!shared && config.source) {
+    throw new Error(`Edge-cache collection "${key}" declares source "${config.source}" but no other collection uses table "${config.tableName}".`);
+  }
+}
+var sourcesByTable = /* @__PURE__ */ new Map();
+for (const [key, config] of Object.entries(edgeCacheCollections)) {
+  if (!config.source)
+    continue;
+  const seen = sourcesByTable.get(`${config.tableName}:${config.source}`);
+  if (seen) {
+    throw new Error(`Edge-cache collections "${seen}" and "${key}" both use source "${config.source}" on table "${config.tableName}".`);
+  }
+  sourcesByTable.set(`${config.tableName}:${config.source}`, key);
+}
+
+export {
+  BaseCollections
+};

package/chunks/chunk-3MZYUBJ6.js

@@ -0,0 +1,49 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __reExport,
+  __toESM
+};