@rebasepro/types 0.16.0 → 0.16.1-canary.g041c925

package/dist/index.es.js

@@ -400,8 +400,7 @@ var ADMIN_COLLECTION_KEYS = [
 	"selectionController",
 	"selectionEnabled",
 	"sideDialogWidth",
-	"sort",
-	"titleProperty"
+	"sort"
 ];
 /**
 * Every key that belongs inside a *property's* `admin` block, as data.
@@ -940,6 +939,20 @@ function usesLegacyRlsFunctions(sql) {
 //#endregion
 //#region src/types/backend.ts
 /**
+* Type guard: can this admin plan a live schema change?
+*
+* Planning is engine-specific — it renders DDL, a Drizzle schema and the
+* declarative SQL artifacts — so the implementation lives in the driver
+* package. The server detects the capability structurally, exactly as it does
+* for SQL, rather than importing an engine it is supposed to know nothing
+* about.
+*
+* @group Admin
+*/
+function isSchemaEditingAdmin(admin) {
+	return !!admin && typeof admin.planSchemaChange === "function";
+}
+/**
 * Type guard: does this admin support SQL operations?
 * @group Admin
 */
@@ -968,6 +981,14 @@ function isBranchAdmin(admin) {
 	return !!admin && typeof admin.createBranch === "function";
 }
 //#endregion
+//#region src/types/schema_editing.ts
+var DEFAULT_COMMIT_PATHS = {
+	schemaFile: "backend/src/schema.generated.ts",
+	ddlFile: "drizzle/schema.sql",
+	policiesFile: "drizzle/policies.sql",
+	searchFile: "drizzle/search.sql"
+};
+//#endregion
 //#region src/types/channel_bus.ts
 /**
 * Whether `setting` is an already-constructed transport rather than a request
@@ -981,6 +1002,351 @@ function isChannelBusInstance(setting) {
 	return typeof setting?.publish === "function";
 }
 //#endregion
+//#region src/types/resources.ts
+/** The key a resource takes when a project declares only one of its kind. */
+var DEFAULT_RESOURCE_KEY = "(default)";
+var BRAND = Symbol.for("@rebasepro/types.resource");
+/** Whether a value is a resource handle rather than a plain string key. */
+function isResourceHandle(value) {
+	return typeof value === "object" && value !== null && BRAND in value;
+}
+/** The key a resource reference names, whether it is a handle or already a key. */
+function resourceKeyOf(ref) {
+	return isResourceHandle(ref) ? ref.key : ref;
+}
+var GLOBAL_KEY = Symbol.for("@rebasepro/types.resourceRegistry");
+function registry() {
+	const g = globalThis;
+	let existing = g[GLOBAL_KEY];
+	if (!existing) {
+		existing = {
+			kinds: /* @__PURE__ */ new Map(),
+			declarations: /* @__PURE__ */ new Map()
+		};
+		g[GLOBAL_KEY] = existing;
+	}
+	return existing;
+}
+/** `kind:key`, the graph's primary key. */
+function declarationId(kind, key) {
+	return `${kind}:${key}`;
+}
+/** Register a resource kind. Idempotent for an identical spec; throws on a conflicting one. */
+function registerResourceKind(spec) {
+	const existing = registry().kinds.get(spec.kind);
+	if (existing && JSON.stringify(existing) !== JSON.stringify(spec)) throw new Error(`Resource kind "${spec.kind}" is already registered with a different definition. Two packages cannot define the same kind.`);
+	registry().kinds.set(spec.kind, spec);
+}
+/** Every registered kind, for validators and for `rebase doctor`. */
+function resourceKinds() {
+	return [...registry().kinds.values()];
+}
+/** One registered kind, or undefined. */
+function resourceKind(kind) {
+	return registry().kinds.get(kind);
+}
+var COMMON_OPTION_KEYS = [
+	"engine",
+	"transport",
+	"label"
+];
+/** Whether an engine is one the kind knows, or an explicit `custom:` opt-out. */
+function isValidEngine(spec, engine) {
+	return engine.startsWith("custom:") || spec.engines.includes(engine);
+}
+/**
+* Declare a resource. The primitive every kind's constructor is built from.
+*
+* Redeclaring the same `kind:key` with a *different* shape throws rather than
+* merging. Merging is what the old storage path did, and it silently discarded
+* one of the two engines — a declaration accepted and then ignored, which is
+* the failure this whole model exists to remove. Redeclaring it identically is
+* fine: a config module evaluated twice must not be an error.
+*/
+function declareResource(kind, key = DEFAULT_RESOURCE_KEY, options = {}) {
+	const spec = registry().kinds.get(kind);
+	if (!spec) {
+		const known = [...registry().kinds.keys()].sort().join(", ") || "none";
+		throw new Error(`Unknown resource kind "${kind}". Registered kinds: ${known}. Call registerResourceKind() before declaring one.`);
+	}
+	if (!key || typeof key !== "string" || key.trim() === "") throw new Error(`A ${kind} needs a non-empty key.`);
+	const engine = options.engine ?? spec.defaultEngine;
+	if (!isValidEngine(spec, engine)) throw new Error(`Unknown ${kind} engine "${engine}" for "${key}". Known engines: ${spec.engines.join(", ")}. An engine this build does not ship is spelled "custom:${engine}", which says so at the call site rather than failing later.`);
+	const allowed = /* @__PURE__ */ new Set([...COMMON_OPTION_KEYS, ...spec.optionKeys ?? []]);
+	const unknown = Object.keys(options).filter((k) => !allowed.has(k));
+	if (unknown.length > 0) throw new Error(`Unknown option(s) on ${kind} "${key}": ${unknown.join(", ")}. A ${kind} accepts: ${[...allowed].sort().join(", ")}.`);
+	const extra = {};
+	for (const k of spec.optionKeys ?? []) if (options[k] !== void 0) extra[k] = options[k];
+	const declaration = {
+		kind,
+		key,
+		engine,
+		transport: options.transport ?? "server",
+		...options.label !== void 0 ? { label: options.label } : {},
+		options: Object.freeze(extra)
+	};
+	const id = declarationId(kind, key);
+	const previous = registry().declarations.get(id);
+	if (previous) {
+		if (JSON.stringify(previous) !== JSON.stringify(declaration)) throw new Error(`${kind} "${key}" is declared twice with different configuration. Declare it once and export it — two declarations of one resource is the ambiguity this model exists to remove, so it is refused rather than merged.`);
+	} else registry().declarations.set(id, declaration);
+	return {
+		...declaration,
+		toString() {
+			return key;
+		},
+		[BRAND]: true
+	};
+}
+/** Every declared resource, in declaration order, optionally filtered by kind. */
+function declaredResources(kind) {
+	const all = [...registry().declarations.values()];
+	return kind ? all.filter((r) => r.kind === kind) : all;
+}
+/**
+* Forget every declaration, keeping registered kinds.
+*
+* For tests and for a CLI that evaluates more than one project in a process.
+* Kinds survive because they are registered by module import, which will not
+* happen a second time.
+*/
+function resetDeclaredResources() {
+	registry().declarations.clear();
+}
+/**
+* The env-var suffix a resource's bindings use: `__ANALYTICS` for `analytics`,
+* and nothing at all for the default-keyed one.
+*
+* The default takes no suffix so that a project with one database configured
+* through plain `DATABASE_URL` keeps working having declared nothing — the
+* overwhelmingly common project must not have to say so.
+*/
+function resourceEnvSuffix(key) {
+	if (key === "(default)") return "";
+	return `__${key.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+}
+/**
+* Two resources of a kind whose keys differ but whose env suffixes do not.
+*
+* `media-files` and `media_files` both become `__MEDIA_FILES`, so one would
+* silently read the other's configuration. Returned rather than thrown so the
+* caller can report it with the rest of a validation pass.
+*/
+function findEnvSuffixCollision(keys) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const suffix = resourceEnvSuffix(key);
+		const previous = seen.get(suffix);
+		if (previous !== void 0 && previous !== key) return {
+			a: previous,
+			b: key,
+			suffix
+		};
+		seen.set(suffix, key);
+	}
+	return null;
+}
+/** The current graph format version. */
+var RESOURCE_GRAPH_VERSION = 1;
+/** Build a graph from the current declarations, sorted for a stable diff. */
+function buildResourceGraph() {
+	return {
+		version: 1,
+		resources: declaredResources().slice().sort((a, b) => a.kind.localeCompare(b.kind) || a.key.localeCompare(b.key))
+	};
+}
+/**
+* The environment variables worth writing for a resource, given its engine.
+*
+* Falls back to every base the kind reads when the engine is unknown — a
+* `custom:` engine gets the full list rather than an empty one, because
+* guessing narrow would silently omit the variable it actually needs.
+*/
+function envBasesForResource(declaration) {
+	const spec = resourceKind(declaration.kind);
+	if (!spec) return [];
+	return spec.envBasesByEngine?.[declaration.engine] ?? spec.envBases;
+}
+//#endregion
+//#region src/types/resource_kinds.ts
+/**
+* The kinds Rebase ships, and the constructors a project declares them with.
+*
+* Each kind is registered rather than hardcoded, so a fourth one arrives
+* without editing a manifest schema, a validator and a switch statement. That
+* cost is precisely why databases and buckets ended up declared in different
+* files with different rules — the cheapest thing to do was always to bolt the
+* new kind onto whichever home was nearest.
+*
+* A kind owns its engine list. `custom:<id>` is always accepted, so a build
+* that ships an engine this package has never heard of says so at the call site
+* instead of looking like a typo of one that exists.
+*/
+registerResourceKind({
+	kind: "database",
+	engines: [
+		"postgres",
+		"mongodb",
+		"firestore",
+		"sqlite"
+	],
+	defaultEngine: "postgres",
+	envBases: [
+		"DATABASE_URL",
+		"REBASE_DRIVER",
+		"REBASE_DB_POOL_MAX"
+	],
+	optionKeys: ["databaseId", "migrations"],
+	implicitDefault: true
+});
+/**
+* Declare a database.
+*
+* ```ts
+* export const main      = database();               // the default one
+* export const analytics = database("analytics");    // reads DATABASE_URL__ANALYTICS
+* ```
+*/
+function database(key = DEFAULT_RESOURCE_KEY, options = {}) {
+	return declareResource("database", key, options);
+}
+registerResourceKind({
+	kind: "bucket",
+	engines: [
+		"local",
+		"s3",
+		"gcs",
+		"azure",
+		"firebase"
+	],
+	defaultEngine: "local",
+	envBases: [
+		"S3_BUCKET",
+		"GCS_BUCKET",
+		"STORAGE_BUCKET",
+		"STORAGE_PUBLIC_URL"
+	],
+	envBasesByEngine: {
+		local: ["STORAGE_BUCKET"],
+		s3: [
+			"S3_BUCKET",
+			"STORAGE_ENDPOINT",
+			"STORAGE_REGION",
+			"STORAGE_PUBLIC_URL"
+		],
+		gcs: ["GCS_BUCKET", "STORAGE_PUBLIC_URL"],
+		azure: ["STORAGE_BUCKET", "STORAGE_PUBLIC_URL"],
+		firebase: ["STORAGE_BUCKET", "STORAGE_PUBLIC_URL"]
+	},
+	optionKeys: ["publicRead", "prefix"],
+	implicitDefault: false
+});
+/**
+* Declare a bucket.
+*
+* ```ts
+* export const media = bucket("media", { transport: "direct" });
+* ```
+*
+* `transport: "direct"` means a provider SDK talks to the bucket and the
+* backend is not in the upload path.
+*/
+function bucket(key = DEFAULT_RESOURCE_KEY, options = {}) {
+	return declareResource("bucket", key, options);
+}
+registerResourceKind({
+	kind: "topic",
+	engines: ["jobs"],
+	defaultEngine: "jobs",
+	envBases: ["REBASE_TOPIC_URL"],
+	optionKeys: ["delivery", "maxAttempts"],
+	implicitDefault: false
+});
+var runtimeHolder = { current: null };
+/** Install the transport topics publish through. Called by the server at boot. */
+function setTopicRuntime(runtime) {
+	runtimeHolder.current = runtime;
+}
+var subscriptions = [];
+/** Every declared subscription, for the worker to wire and the graph to record. */
+function declaredSubscriptions(topic) {
+	return topic ? subscriptions.filter((s) => s.topic === topic) : subscriptions.slice();
+}
+/** Forget declared subscriptions. For tests, alongside `resetDeclaredResources`. */
+function resetDeclaredSubscriptions() {
+	subscriptions.length = 0;
+}
+/**
+* Declare a topic.
+*
+* ```ts
+* export const signups = topic<{ userId: string }>("signups");
+* signups.subscription("send-welcome", async (event) => { … });
+* await signups.publish({ userId });
+* ```
+*/
+function topic(key, options = {}) {
+	if (options.delivery === "at-most-once") throw new Error(`Topic "${key}" asks for at-most-once delivery, which no shipped transport implements. The durable queue behind topics retries, so it is at-least-once and a handler must tolerate seeing an event twice. Refused rather than quietly given the other guarantee.`);
+	return {
+		...declareResource("topic", key, options),
+		toString() {
+			return key;
+		},
+		async publish(event) {
+			const runtime = runtimeHolder.current;
+			if (!runtime) throw new Error(`Cannot publish to topic "${key}": no topic runtime is installed. Publishing works inside a running Rebase backend; this looks like config being evaluated outside one (a build, a script, or a test without a harness).`);
+			await runtime.publish(key, event);
+		},
+		subscription(name, handler, subOptions = {}) {
+			if (!name || name.trim() === "") throw new Error(`A subscription on topic "${key}" needs a non-empty name.`);
+			if (subscriptions.some((s) => s.topic === key && s.name === name)) throw new Error(`Topic "${key}" already has a subscription named "${name}". The name is what a job row records and what a retry counts against, so two cannot share one.`);
+			subscriptions.push({
+				topic: key,
+				name,
+				handler,
+				...subOptions.maxAttempts !== void 0 ? { maxAttempts: subOptions.maxAttempts } : {}
+			});
+		}
+	};
+}
+/**
+* The declared databases, in the shape `<Rebase dataSources>` takes.
+*
+* The frontend needs to know which sources exist and how they are reached — a
+* `direct`-transport source is one the browser talks to itself — and it imports
+* the same config package the backend does. Without these it would mean writing
+* the list a second time, by hand, next to the declarations, which is precisely
+* the two-homes problem this model removed everywhere else.
+*
+* ```tsx
+* import "../config/resources";                 // registers them
+* import { declaredDataSources, declaredStorageSources } from "@rebasepro/types";
+*
+* <Rebase dataSources={declaredDataSources()} storageSources={declaredStorageSources()} />
+* ```
+*
+* The import is what registers them, so a bundler that drops an unused module
+* would leave this empty — hence the side-effect import above rather than a
+* bare re-export.
+*/
+function declaredDataSources() {
+	return declaredResources("database").map((r) => ({
+		key: r.key,
+		engine: r.engine,
+		transport: r.transport,
+		...r.label !== void 0 ? { label: r.label } : {}
+	}));
+}
+/** The declared buckets, in the shape `<Rebase storageSources>` takes. */
+function declaredStorageSources() {
+	return declaredResources("bucket").map((r) => ({
+		key: r.key,
+		engine: r.engine,
+		transport: r.transport,
+		...r.label !== void 0 ? { label: r.label } : {}
+	}));
+}
+//#endregion
 //#region src/types/storage_source.ts
 /**
 * Describes a named storage backend — a place files live.
@@ -1105,6 +1471,41 @@ function isLazyComponentRef(ref) {
 //#endregion
 //#region src/types/project_manifest.ts
 /**
+* Path prefixes the backend owns, which no static app may claim.
+*
+* One process — and, on the platform, one hostname — serves both the API and
+* however many static apps a project has. Mounting is longest-path-first, so an
+* app declaring `/api` would win against the API itself and every request to it
+* would be answered with that app's `index.html`: a 200 carrying HTML where the
+* caller expected JSON, from a project that looks deployed and healthy.
+*
+* Declared here rather than in either enforcer because both must agree. The CLI
+* checks it so a developer finds out while editing `rebase.json`; the control
+* plane checks it again at deploy intake, because the front door's correctness
+* cannot rest on a check that ran in somebody else's CLI — and a repository can
+* be deployed by a CLI older than this rule.
+*/
+var RESERVED_BACKEND_PREFIXES = [
+	"/api",
+	"/health",
+	"/healthz",
+	"/livez",
+	"/readyz",
+	"/metrics"
+];
+/**
+* Whether `path` collides with a prefix the backend owns.
+*
+* Compares at segment boundaries, so `/api` and `/api/v2` collide while
+* `/apidocs` does not — the same rule the router matches with, because a check
+* that is stricter than the router rejects paths that would have worked, and one
+* that is looser admits paths that will not.
+*/
+function reservedPrefixFor(path) {
+	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+	return RESERVED_BACKEND_PREFIXES.find((reserved) => normalized === reserved || normalized.startsWith(`${reserved}/`));
+}
+/**
 * Version of the bundle *format* itself.
 *
 * Bumped only when the on-disk layout changes in a way an older runtime could
@@ -1128,6 +1529,31 @@ var BUNDLE_FORMAT_VERSION = 2;
 * any number of minors and patches while this stays put. It changes only when
 * the bundle/runtime contract breaks compatibility, and a project's
 * `manifest.runtime` range is matched against *this*.
+*
+* ## v2 — resources are declared, not configured
+*
+* `RebaseBackendConfig.dataSources` and `.storageSources` are gone. A project
+* declares its databases and buckets with `database()` / `bucket()` in its
+* config, and the runtime reads those declarations.
+*
+* This had to be a major, and the reason is the managed tier: it moves projects
+* onto new images WITHOUT rebuilding them. A bundle built against v1 exports
+* those keys, and a v2 runtime refuses them at boot — so without this bump, one
+* image rollout would crash-loop every tenant that had ever declared a second
+* database or bucket, in a wave, with the cause in a container log nobody is
+* watching.
+*
+* With the bump, a v1 bundle on a v2 runtime is refused by
+* `assertBundleCompatibility` with the remedy in the message, and the platform
+* keeps it on a v1 image until it is rebuilt. That is the whole purpose of this
+* number.
+*
+* **Release order matters and is not optional.** The control plane is the side
+* that rejects, so it ships FIRST: raise `SUPPORTED_RUNTIME_CONTRACT` in the
+* saas repo (it rejects only `contract >` its own, so it then accepts both),
+* deploy that, and only then release a runtime implementing v2. Shipping the
+* runtime first turns every deploy into a rejected intake blaming the tenant's
+* bundle.
 */
 var RUNTIME_CONTRACT_VERSION = 1;
 /** Header carrying the schema version an SDK was generated from. */
@@ -1445,6 +1871,6 @@ function isPublicStoragePath(path) {
 	return p.startsWith("public/") || p.startsWith(`default/public/`);
 }
 //#endregion
-export { ADMIN_COLLECTION_KEYS, ADMIN_PROPERTY_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_FILTERABLE_RELATION_KINDS, DEFAULT_FUZZY_THRESHOLD, DEFAULT_LIST_LIMIT, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_WEIGHT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, LEGACY_RLS_JWT_SQL, LEGACY_RLS_ROLES_SQL, LEGACY_RLS_SCHEMA, LEGACY_RLS_UID_SQL, ListLimitError, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REBASE_SCHEMA, RELEVANCE_SORT_FIELD, REST_TO_CANONICAL, RLS_JWT_SQL, RLS_ROLES_SQL, RLS_UID_SQL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, canonicalSchemaPayload, computeSchemaVersion, deserializeCollections, encodeRelationAggregateSort, findStorageSuffixCollision, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, hasForeignKeyOnTarget, isAnonymousUid, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isManyToMany, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isRelationAggregateSort, isRelationalCollectionConfig, isSQLAdmin, isSchemaAdmin, isSerializedCollectionRef, isToMany, nestAdminCollectionKeys, nestAdminKeysOf, nestAdminPropertyKeys, normalizeStorageSources, parseRelationAggregateSort, policy, registerDataSourceCapabilities, resolveClientListLimit, rewriteLegacyRlsFunctions, serializeCollections, sortKeyToString, storageEnvSuffix, toCanonicalOp, usesLegacyRlsFunctions };
+export { ADMIN_COLLECTION_KEYS, ADMIN_PROPERTY_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_COMMIT_PATHS, DEFAULT_DATA_SOURCE_KEY, DEFAULT_FILTERABLE_RELATION_KINDS, DEFAULT_FUZZY_THRESHOLD, DEFAULT_LIST_LIMIT, DEFAULT_RESOURCE_KEY, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_WEIGHT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, LEGACY_RLS_JWT_SQL, LEGACY_RLS_ROLES_SQL, LEGACY_RLS_SCHEMA, LEGACY_RLS_UID_SQL, ListLimitError, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REBASE_SCHEMA, RELEVANCE_SORT_FIELD, RESERVED_BACKEND_PREFIXES, RESOURCE_GRAPH_VERSION, REST_TO_CANONICAL, RLS_JWT_SQL, RLS_ROLES_SQL, RLS_UID_SQL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, bucket, buildResourceGraph, canonicalSchemaPayload, computeSchemaVersion, database, declareResource, declaredDataSources, declaredResources, declaredStorageSources, declaredSubscriptions, deserializeCollections, encodeRelationAggregateSort, envBasesForResource, findEnvSuffixCollision, findStorageSuffixCollision, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, hasForeignKeyOnTarget, isAnonymousUid, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isManyToMany, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isRelationAggregateSort, isRelationalCollectionConfig, isResourceHandle, isSQLAdmin, isSchemaAdmin, isSchemaEditingAdmin, isSerializedCollectionRef, isToMany, isValidEngine, nestAdminCollectionKeys, nestAdminKeysOf, nestAdminPropertyKeys, normalizeStorageSources, parseRelationAggregateSort, policy, registerDataSourceCapabilities, registerResourceKind, reservedPrefixFor, resetDeclaredResources, resetDeclaredSubscriptions, resolveClientListLimit, resourceEnvSuffix, resourceKeyOf, resourceKind, resourceKinds, rewriteLegacyRlsFunctions, serializeCollections, setTopicRuntime, sortKeyToString, storageEnvSuffix, toCanonicalOp, topic, usesLegacyRlsFunctions };
 
 //# sourceMappingURL=index.es.js.map