@cedarjs/tenancy 7.0.0-canary.3092

package/dist/prismaExtension.js

@@ -0,0 +1,583 @@
+import { Prisma as PrismaExtension } from "@prisma/client/extension";
+import { context } from "@cedarjs/context";
+import { getAsyncStoreInstance } from "@cedarjs/context/dist/store.js";
+import { getCurrentOrg } from "./context.js";
+import { TenantScopeError } from "./errors.js";
+function getRuntimeDataModel(client) {
+  const candidate = client;
+  if (!candidate._runtimeDataModel || typeof candidate._runtimeDataModel !== "object" || typeof candidate._runtimeDataModel.models !== "object") {
+    throw new Error(
+      "@cedarjs/tenancy could not find a `_runtimeDataModel` on this Prisma Client. createTenancyExtension() reads it to discover relations between models; check that the installed `@prisma/client` version supports Client Extensions (`$extends`)."
+    );
+  }
+  return candidate._runtimeDataModel;
+}
+function getInlineSchemaText(client) {
+  const candidate = client;
+  const inlineSchema = candidate._engineConfig?.inlineSchema;
+  return typeof inlineSchema === "string" ? inlineSchema : void 0;
+}
+function findModelBodyRange(schemaText, searchFrom) {
+  const headerPattern = /model\s+(\w+)\s*\{/g;
+  headerPattern.lastIndex = searchFrom;
+  const headerMatch = headerPattern.exec(schemaText);
+  if (!headerMatch) {
+    return null;
+  }
+  const modelName = headerMatch[1];
+  const bodyStart = headerMatch.index + headerMatch[0].length;
+  let depth = 1;
+  let index = bodyStart;
+  let quote;
+  for (; index < schemaText.length && depth > 0; index++) {
+    const char = schemaText[index];
+    if (quote) {
+      if (char === "\\") {
+        index++;
+      } else if (char === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+    } else if (char === "/" && schemaText[index + 1] === "/") {
+      const newlineIndex = schemaText.indexOf("\n", index);
+      index = newlineIndex === -1 ? schemaText.length : newlineIndex - 1;
+    } else if (char === "{") {
+      depth++;
+    } else if (char === "}") {
+      depth--;
+    }
+  }
+  if (depth !== 0) {
+    return null;
+  }
+  return { modelName, bodyStart, bodyEnd: index - 1 };
+}
+function parseListFieldsFromSchema(schemaText) {
+  const fieldsByModel = /* @__PURE__ */ new Map();
+  let searchFrom = 0;
+  let block = findModelBodyRange(schemaText, searchFrom);
+  while (block !== null) {
+    const { modelName, bodyStart, bodyEnd } = block;
+    const body = schemaText.slice(bodyStart, bodyEnd);
+    const knownFields = /* @__PURE__ */ new Set();
+    const listFields = /* @__PURE__ */ new Set();
+    for (const rawLine of body.split("\n")) {
+      const line = rawLine.split("//")[0].trim();
+      if (!line || line.startsWith("@@")) {
+        continue;
+      }
+      const [fieldName, fieldType] = line.split(/\s+/);
+      if (!fieldName || !fieldType) {
+        continue;
+      }
+      knownFields.add(fieldName);
+      if (fieldType.endsWith("[]")) {
+        listFields.add(fieldName);
+      }
+    }
+    fieldsByModel.set(modelName, { knownFields, listFields });
+    searchFrom = bodyEnd + 1;
+    block = findModelBodyRange(schemaText, searchFrom);
+  }
+  return fieldsByModel;
+}
+function getListFieldsByModel(client) {
+  const schemaText = getInlineSchemaText(client);
+  return schemaText === void 0 ? void 0 : parseListFieldsFromSchema(schemaText);
+}
+function pascalToCamel(name) {
+  return name.length === 0 ? name : name.charAt(0).toLowerCase() + name.slice(1);
+}
+const FRAMEWORK_MODELS = /* @__PURE__ */ new Set(["RW_DataMigration"]);
+function resolveTenantModelNames(modelsConfig, runtimeDataModel) {
+  const allModelNames = Object.keys(runtimeDataModel.models).filter(
+    (name) => !FRAMEWORK_MODELS.has(name)
+  );
+  const allAccessorNames = new Set(allModelNames.map(pascalToCamel));
+  if (Array.isArray(modelsConfig)) {
+    const configured = new Set(modelsConfig.map((name) => String(name)));
+    const unknown2 = [...configured].filter(
+      (name) => !allAccessorNames.has(name)
+    );
+    if (unknown2.length > 0) {
+      throw new TenantScopeError(
+        `Unknown model${unknown2.length > 1 ? "s" : ""} in tenancy config.models: ${unknown2.join(", ")}. Expected one of: ${[...allAccessorNames].join(", ")}.`
+      );
+    }
+    return new Set(
+      allModelNames.filter((name) => configured.has(pascalToCamel(name)))
+    );
+  }
+  const excluded = new Set(modelsConfig.allExcept.map((name) => String(name)));
+  const unknown = [...excluded].filter((name) => !allAccessorNames.has(name));
+  if (unknown.length > 0) {
+    throw new TenantScopeError(
+      `Unknown model${unknown.length > 1 ? "s" : ""} in tenancy config.models.allExcept: ${unknown.join(", ")}. Expected one of: ${[...allAccessorNames].join(", ")}.`
+    );
+  }
+  return new Set(
+    allModelNames.filter((name) => !excluded.has(pascalToCamel(name)))
+  );
+}
+function tenantScopeError(model) {
+  const inRequest = getAsyncStoreInstance().getStore() !== void 0;
+  if (!inRequest) {
+    return new TenantScopeError(
+      `"${model}" is tenant-owned, and this code is running outside a request, so there is no organization in scope. Use \`db.$forOrg(organizationId)\` when the organization is known (a job or a webhook), or \`db.$withoutTenant()\` when the code works across organizations on purpose (a seed, a data migration, an admin task).`
+    );
+  }
+  if (!context.currentUser) {
+    return new TenantScopeError(
+      `"${model}" is tenant-owned, and this request has nobody signed in, so no organization was resolved for it. Read one organization's data for an anonymous visitor with \`db.$forOrg(organizationId)\`, which names the organization explicitly.`
+    );
+  }
+  return new TenantScopeError(
+    `"${model}" is tenant-owned, and the signed-in user has no organization in scope for this request. Either the request carried no \`cedar-org\` header, which queries made outside \`OrgScope\` and functions not wrapped in \`withTenancy\` do not, or the user has no membership yet and needs one before they can read tenant-owned data.`
+  );
+}
+function requireTenantId(ctx, model) {
+  const tenantId = ctx.getTenantId();
+  if (tenantId === void 0) {
+    throw tenantScopeError(model);
+  }
+  return tenantId;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function findField(runtimeDataModel, modelName, fieldName) {
+  return runtimeDataModel.models[modelName]?.fields.find(
+    (field) => field.name === fieldName
+  );
+}
+function isRelationField(field) {
+  return field?.kind === "object";
+}
+function isListByForeignKeyHeuristic(ctx, modelName, field) {
+  const foreignKeyFieldName = `${field.name}Id`;
+  const ownFields = ctx.runtimeDataModel.models[modelName]?.fields ?? [];
+  const hasOwnForeignKey = ownFields.some(
+    (f) => f.kind === "scalar" && f.name === foreignKeyFieldName
+  );
+  return !hasOwnForeignKey;
+}
+function isListRelationField(ctx, modelName, field) {
+  const parsedModel = ctx.listFieldsByModel?.get(modelName);
+  if (parsedModel?.knownFields.has(field.name)) {
+    return parsedModel.listFields.has(field.name);
+  }
+  return isListByForeignKeyHeuristic(ctx, modelName, field);
+}
+function mapRows(value, fn) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(fn);
+  }
+  return fn(value);
+}
+function mergeWhereWithTenant(where, tenantField, tenantId) {
+  if (where === void 0 || where === null) {
+    return { [tenantField]: tenantId };
+  }
+  return { AND: [where, { [tenantField]: tenantId }] };
+}
+function injectWhereRow(ctx, model, where) {
+  return mapRows(where, (row) => {
+    if (!isPlainObject(row)) {
+      return row;
+    }
+    if (!ctx.tenantModels.has(model)) {
+      return row;
+    }
+    const tenantId = requireTenantId(ctx, model);
+    return { ...row, [ctx.tenantField]: tenantId };
+  });
+}
+function injectCreateRow(ctx, model, data, options = {}) {
+  return mapRows(data, (row) => injectCreateRowSingle(ctx, model, row, options));
+}
+function injectCreateRowSingle(ctx, model, row, options) {
+  if (!isPlainObject(row)) {
+    return row;
+  }
+  const next = { ...row };
+  if (ctx.tenantModels.has(model)) {
+    const tenantId = requireTenantId(ctx, model);
+    const existing = next[ctx.tenantField];
+    if (existing !== void 0 && existing !== tenantId) {
+      throw new TenantScopeError(
+        `Cannot set "${model}.${ctx.tenantField}" to a different organization than the current tenant.`
+      );
+    }
+    next[ctx.tenantField] = tenantId;
+  }
+  if (!options.shallow) {
+    for (const [key, value] of Object.entries(next)) {
+      const field = findField(ctx.runtimeDataModel, model, key);
+      if (isRelationField(field) && isPlainObject(value)) {
+        next[key] = processRelationOperations(ctx, field, value);
+      }
+    }
+  }
+  return next;
+}
+function validateAndRecurseUpdateData(ctx, model, data) {
+  if (!isPlainObject(data)) {
+    return data;
+  }
+  const next = { ...data };
+  if (ctx.tenantModels.has(model) && ctx.tenantField in next) {
+    const raw = next[ctx.tenantField];
+    const value = isPlainObject(raw) && "set" in raw ? raw.set : raw;
+    const tenantId = requireTenantId(ctx, model);
+    if (value !== tenantId) {
+      throw new TenantScopeError(
+        `Cannot change "${model}.${ctx.tenantField}" to a different organization.`
+      );
+    }
+  }
+  for (const [key, value] of Object.entries(next)) {
+    const field = findField(ctx.runtimeDataModel, model, key);
+    if (isRelationField(field) && isPlainObject(value)) {
+      next[key] = processRelationOperations(ctx, field, value);
+    }
+  }
+  return next;
+}
+function processUpdateEntry(ctx, model, entry) {
+  if (!isPlainObject(entry)) {
+    return entry;
+  }
+  if ("where" in entry && "data" in entry) {
+    return {
+      ...entry,
+      where: injectWhereRow(ctx, model, entry.where),
+      data: validateAndRecurseUpdateData(ctx, model, entry.data)
+    };
+  }
+  return validateAndRecurseUpdateData(ctx, model, entry);
+}
+function processUpdateManyEntry(ctx, model, entry) {
+  if (!isPlainObject(entry)) {
+    return entry;
+  }
+  return {
+    ...entry,
+    where: injectWhereRow(ctx, model, entry.where),
+    data: validateAndRecurseUpdateData(ctx, model, entry.data)
+  };
+}
+function processUpsertEntry(ctx, model, entry) {
+  if (!isPlainObject(entry)) {
+    return entry;
+  }
+  const next = { ...entry };
+  if ("where" in next) {
+    next.where = injectWhereRow(ctx, model, next.where);
+  }
+  if ("create" in next) {
+    next.create = injectCreateRow(ctx, model, next.create);
+  }
+  if ("update" in next) {
+    next.update = validateAndRecurseUpdateData(ctx, model, next.update);
+  }
+  return next;
+}
+function processRelationOperations(ctx, field, opsValue) {
+  const targetModel = field.type;
+  const next = { ...opsValue };
+  if ("create" in next) {
+    next.create = injectCreateRow(ctx, targetModel, next.create);
+  }
+  if ("createMany" in next && isPlainObject(next.createMany)) {
+    const createMany = next.createMany;
+    next.createMany = {
+      ...createMany,
+      data: injectCreateRow(ctx, targetModel, createMany.data, {
+        shallow: true
+      })
+    };
+  }
+  if ("connect" in next) {
+    next.connect = injectWhereRow(ctx, targetModel, next.connect);
+  }
+  if ("connectOrCreate" in next) {
+    next.connectOrCreate = mapRows(next.connectOrCreate, (entry) => {
+      if (!isPlainObject(entry)) {
+        return entry;
+      }
+      return {
+        ...entry,
+        where: injectWhereRow(ctx, targetModel, entry.where),
+        create: injectCreateRow(ctx, targetModel, entry.create)
+      };
+    });
+  }
+  if ("disconnect" in next) {
+    next.disconnect = injectWhereRow(ctx, targetModel, next.disconnect);
+  }
+  if ("set" in next) {
+    next.set = injectWhereRow(ctx, targetModel, next.set);
+  }
+  if ("delete" in next) {
+    next.delete = injectWhereRow(ctx, targetModel, next.delete);
+  }
+  if ("deleteMany" in next) {
+    next.deleteMany = injectWhereRow(ctx, targetModel, next.deleteMany);
+  }
+  if ("update" in next) {
+    next.update = mapRows(
+      next.update,
+      (entry) => processUpdateEntry(ctx, targetModel, entry)
+    );
+  }
+  if ("updateMany" in next) {
+    next.updateMany = mapRows(
+      next.updateMany,
+      (entry) => processUpdateManyEntry(ctx, targetModel, entry)
+    );
+  }
+  if ("upsert" in next) {
+    next.upsert = mapRows(
+      next.upsert,
+      (entry) => processUpsertEntry(ctx, targetModel, entry)
+    );
+  }
+  return next;
+}
+function walkRelationIncludeValue(ctx, model, field, value) {
+  const targetModel = field.type;
+  const shouldScope = ctx.tenantModels.has(targetModel) && isListRelationField(ctx, model, field);
+  if (value === true) {
+    if (!shouldScope) {
+      return true;
+    }
+    const tenantId = requireTenantId(ctx, targetModel);
+    return { where: { [ctx.tenantField]: tenantId } };
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const next = { ...value };
+  if (shouldScope) {
+    const tenantId = requireTenantId(ctx, targetModel);
+    next.where = mergeWhereWithTenant(next.where, ctx.tenantField, tenantId);
+  }
+  if ("include" in next) {
+    next.include = walkIncludeOrSelect(ctx, targetModel, next.include);
+  }
+  if ("select" in next) {
+    next.select = walkIncludeOrSelect(ctx, targetModel, next.select);
+  }
+  return next;
+}
+function expandCountShorthand(ctx, model) {
+  const listRelations = (ctx.runtimeDataModel.models[model]?.fields ?? []).filter(
+    (field) => isRelationField(field) && isListRelationField(ctx, model, field)
+  );
+  const scopesAnything = listRelations.some(
+    (field) => ctx.tenantModels.has(field.type)
+  );
+  if (!scopesAnything) {
+    return true;
+  }
+  const select = {};
+  for (const field of listRelations) {
+    select[field.name] = walkRelationIncludeValue(ctx, model, field, true);
+  }
+  return { select };
+}
+function walkCountSelect(ctx, model, value) {
+  if (value === true) {
+    return expandCountShorthand(ctx, model);
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const next = { ...value };
+  if (isPlainObject(next.select)) {
+    const select = { ...next.select };
+    for (const [key, fieldValue] of Object.entries(select)) {
+      const field = findField(ctx.runtimeDataModel, model, key);
+      if (isRelationField(field)) {
+        select[key] = walkRelationIncludeValue(ctx, model, field, fieldValue);
+      }
+    }
+    next.select = select;
+  }
+  return next;
+}
+function walkIncludeOrSelect(ctx, model, node) {
+  if (!isPlainObject(node)) {
+    return node;
+  }
+  const next = { ...node };
+  for (const [key, value] of Object.entries(next)) {
+    if (key === "_count") {
+      next._count = walkCountSelect(ctx, model, value);
+      continue;
+    }
+    const field = findField(ctx.runtimeDataModel, model, key);
+    if (!isRelationField(field)) {
+      continue;
+    }
+    next[key] = walkRelationIncludeValue(ctx, model, field, value);
+  }
+  return next;
+}
+const UNIQUE_WHERE_OPERATIONS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow",
+  "update",
+  "delete",
+  "upsert"
+]);
+const FILTER_WHERE_OPERATIONS = /* @__PURE__ */ new Set([
+  "findFirst",
+  "findFirstOrThrow",
+  "findMany",
+  "count",
+  "aggregate",
+  "groupBy",
+  "updateMany",
+  "updateManyAndReturn",
+  "deleteMany"
+]);
+const SUPPORTED_OPERATIONS = /* @__PURE__ */ new Set([
+  ...UNIQUE_WHERE_OPERATIONS,
+  ...FILTER_WHERE_OPERATIONS,
+  "create",
+  "createMany",
+  "createManyAndReturn"
+]);
+function rewriteOperationArgs(ctx, model, operation, argsIn) {
+  if (!SUPPORTED_OPERATIONS.has(operation)) {
+    throw new TenantScopeError(
+      `Operation '${operation}' is not supported on a tenant-scoped client. Use db.$withoutTenant() for operations that intentionally bypass tenant scoping.`
+    );
+  }
+  const args = isPlainObject(argsIn) ? { ...argsIn } : {};
+  const isTenantOwned = ctx.tenantModels.has(model);
+  if (isTenantOwned) {
+    if (UNIQUE_WHERE_OPERATIONS.has(operation)) {
+      const tenantId = requireTenantId(ctx, model);
+      args.where = {
+        ...isPlainObject(args.where) ? args.where : {},
+        [ctx.tenantField]: tenantId
+      };
+    } else if (FILTER_WHERE_OPERATIONS.has(operation)) {
+      const tenantId = requireTenantId(ctx, model);
+      args.where = mergeWhereWithTenant(args.where, ctx.tenantField, tenantId);
+    }
+  }
+  if ("data" in args) {
+    if (operation === "createMany" || operation === "createManyAndReturn") {
+      args.data = injectCreateRow(ctx, model, args.data, { shallow: true });
+    } else if (operation === "create") {
+      args.data = injectCreateRow(ctx, model, args.data);
+    } else if (operation === "update" || operation === "updateMany" || operation === "updateManyAndReturn") {
+      args.data = validateAndRecurseUpdateData(ctx, model, args.data);
+    }
+  }
+  if (operation === "upsert") {
+    if ("create" in args) {
+      args.create = injectCreateRow(ctx, model, args.create);
+    }
+    if ("update" in args) {
+      args.update = validateAndRecurseUpdateData(ctx, model, args.update);
+    }
+  }
+  if ("include" in args) {
+    args.include = walkIncludeOrSelect(ctx, model, args.include);
+  }
+  if ("select" in args) {
+    args.select = walkIncludeOrSelect(ctx, model, args.select);
+  }
+  return args;
+}
+const RAW_QUERY_MESSAGE = "Raw SQL is not allowed on a tenant-scoped client. Use db.$withoutTenant() for raw queries that intentionally bypass tenant scoping.";
+function throwRawQueryBlocked() {
+  throw new TenantScopeError(RAW_QUERY_MESSAGE);
+}
+function createTenancyExtension(config) {
+  const tenantField = config.tenantField ?? "organizationId";
+  const getTenantId = config.getTenantId ?? (() => getCurrentOrg()?.id);
+  return PrismaExtension.defineExtension((client) => {
+    const runtimeDataModel = getRuntimeDataModel(client);
+    const tenantModels = resolveTenantModelNames(
+      config.models,
+      runtimeDataModel
+    );
+    const listFieldsByModel = getListFieldsByModel(client);
+    function buildScopedClient(tenantIdSource) {
+      const ctx = {
+        tenantField,
+        tenantModels,
+        runtimeDataModel,
+        listFieldsByModel,
+        getTenantId: tenantIdSource
+      };
+      return client.$extends({
+        name: "cedarjs-tenancy",
+        query: {
+          $allModels: {
+            // Prisma's extension callback args are opaque (`JsArgs`, a
+            // union over every model's every operation's args type); this
+            // extension's whole job is to handle them generically via the
+            // runtime data model, so they're read as `unknown` and rebuilt
+            // as plain objects rather than cast to a specific args type.
+            async $allOperations({ model, operation, args, query }) {
+              const rewritten = rewriteOperationArgs(
+                ctx,
+                model,
+                operation,
+                args
+              );
+              return query(rewritten);
+            }
+          },
+          $queryRaw: throwRawQueryBlocked,
+          $queryRawUnsafe: throwRawQueryBlocked,
+          $executeRaw: throwRawQueryBlocked,
+          $executeRawUnsafe: throwRawQueryBlocked
+        },
+        client: {
+          $queryRaw: throwRawQueryBlocked,
+          $queryRawUnsafe: throwRawQueryBlocked,
+          $executeRaw: throwRawQueryBlocked,
+          $executeRawUnsafe: throwRawQueryBlocked
+        }
+      });
+    }
+    const scopedClient = buildScopedClient(getTenantId);
+    return scopedClient.$extends({
+      client: {
+        /**
+         * A client scoped to `organizationId` regardless of request
+         * context — for background jobs, webhooks, and other code that
+         * knows the tenant but doesn't run inside a request.
+         */
+        $forOrg(organizationId) {
+          return buildScopedClient(() => organizationId);
+        },
+        /**
+         * An unscoped client for code that intentionally reads or writes
+         * across organizations: seeds, data migrations, admin tooling.
+         * Nothing here is scoped, and raw SQL is allowed.
+         */
+        $withoutTenant() {
+          return client;
+        }
+      }
+    });
+  });
+}
+export {
+  createTenancyExtension,
+  parseListFieldsFromSchema
+};

package/dist/web/OrgContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { OrgContextValue } from './types.js';
+/**
+ * Carries the organization `OrgScope` resolved for the current route.
+ * Read through `useCurrentOrg()`; only defined under `OrgScope`.
+ */
+export declare const OrgContext: React.Context<OrgContextValue | undefined>;
+//# sourceMappingURL=OrgContext.d.ts.map

package/dist/web/OrgContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrgContext.d.ts","sourceRoot":"","sources":["../../src/web/OrgContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,UAAU,4CAEtB,CAAA"}

package/dist/web/OrgContext.js

@@ -0,0 +1,7 @@
+import React from "react";
+const OrgContext = React.createContext(
+  void 0
+);
+export {
+  OrgContext
+};

package/dist/web/OrgScope.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { UseAuth } from '@cedarjs/auth';
+export interface OrgScopeProps {
+    /** Overrides the `orgSlug` route param. */
+    orgSlug?: string;
+    /** Rendered when the user has no membership matching the slug. */
+    notAMember?: React.ReactNode;
+    /**
+     * The app's `useAuth`, so `OrgScope` can read `currentUser.memberships`
+     * without importing app code. Defaults to `useNoAuth`.
+     */
+    useAuth?: UseAuth;
+    /**
+     * Called by `useCurrentOrg().setOrg` instead of navigating, for apps that
+     * select the organization from state rather than a URL segment.
+     */
+    onSetOrg?: (idOrSlug: string) => void;
+    children: React.ReactNode;
+}
+/**
+ * Provides the per-organization Apollo client and `OrgContext` for the
+ * organization matching `orgSlug` (a prop, or else the `orgSlug` route
+ * param). Renders `notAMember` when the current user has no membership in
+ * that organization; otherwise wraps `children` in that organization's own
+ * `ApolloProvider`, so every Cell, `useQuery` and `useMutation` under it
+ * carries the `cedar-org` header and reads from that organization's cache.
+ */
+export declare function OrgScope({ orgSlug: orgSlugProp, notAMember, useAuth, onSetOrg, children, }: OrgScopeProps): React.JSX.Element;
+//# sourceMappingURL=OrgScope.d.ts.map

package/dist/web/OrgScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrgScope.d.ts","sourceRoot":"","sources":["../../src/web/OrgScope.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAe5C,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kEAAkE;IAClE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAYD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EACvB,OAAO,EAAE,WAAW,EACpB,UAAiB,EACjB,OAAmB,EACnB,QAAQ,EACR,QAAQ,GACT,EAAE,aAAa,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAsInC"}