@notionhq/custom-blocks 0.0.58

package/bin/cli/pullManifest.js

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { NOTION_BUILTIN_PROPERTY_IDS } from "../src/bridge/dataSources/propertySchema.js";
+import { extractId, formatUuid } from "./ids.js";
+import { loginHintCommand, ntnApi } from "./ntn.js";
+import { mergeTarget, readTarget, writeTarget } from "./target.js";
+const MANIFEST_FILENAME = "custom_blocks.json";
+const BUILTIN_TYPES = new Set(NOTION_BUILTIN_PROPERTY_IDS);
+// ── Helpers ───────────────────────────────────────────────────────
+function deriveKey(name) {
+    return name
+        .toLowerCase()
+        .replace(/\s+/g, "_")
+        .replace(/[^a-z0-9_]/g, "");
+}
+function plainText(items) {
+    if (!items?.length) {
+        return "Data source";
+    }
+    return items.map(t => t.plain_text ?? "").join("") || "Data source";
+}
+function is404(error) {
+    return error instanceof Error && error.message.includes("404");
+}
+// ── Schema transform ─────────────────────────────────────────────
+function transformProperties(props) {
+    const out = {};
+    for (const prop of Object.values(props)) {
+        if (BUILTIN_TYPES.has(prop.type)) {
+            continue;
+        }
+        const key = deriveKey(prop.name);
+        if (key) {
+            out[key] = { name: prop.name, type: prop.type };
+        }
+    }
+    return out;
+}
+function fetchDataSource(dataSourceId, quiet) {
+    const id = formatUuid(dataSourceId);
+    if (!quiet) {
+        console.log(`  Fetching data source ${id}…`);
+    }
+    const ds = ntnApi(`/v1/data_sources/${id}`);
+    if (!ds.properties || Object.keys(ds.properties).length === 0) {
+        throw new Error(`Data source ${id} has no properties.`);
+    }
+    return {
+        dataSourceId: id,
+        name: plainText(ds.title),
+        properties: transformProperties(ds.properties),
+    };
+}
+/**
+ * Pull schema from a database or data source ID. Tries `/v1/databases/<id>`
+ * first (most common entry point); falls back to `/v1/data_sources/<id>` if
+ * that 404s. ID-type classification (block / view / database / wrong-workspace)
+ * happens upstream in `init.ts` — by the time we get here, the ID is expected
+ * to point at a database or data source.
+ */
+function fetchSchema(id, quiet) {
+    const uuid = formatUuid(id);
+    let dbError;
+    try {
+        if (!quiet) {
+            console.log(`  Fetching database ${uuid}…`);
+        }
+        const db = ntnApi(`/v1/databases/${uuid}`);
+        if (db.object === "database") {
+            if (!db.data_sources?.length) {
+                throw new Error(`Database ${uuid} has no data sources. Confirm you're logged in to the right workspace with \`${loginHintCommand()}\`.`);
+            }
+            return fetchDataSource(db.data_sources[0].id, quiet);
+        }
+    }
+    catch (error) {
+        if (!is404(error)) {
+            throw error;
+        }
+        dbError = error;
+    }
+    try {
+        return fetchDataSource(uuid, quiet);
+    }
+    catch (error) {
+        if (!is404(error)) {
+            throw error;
+        }
+    }
+    throw new Error(dbError instanceof Error
+        ? `${uuid} isn't a database or data source. Confirm you're logged in to the right workspace with \`${loginHintCommand()}\`.`
+        : `${uuid} isn't a database or data source.`);
+}
+export function pullManifest(options) {
+    const { idOrUrl, key = "default", out = MANIFEST_FILENAME, dryRun = false, quiet = false, } = options;
+    const outPath = resolvePath(process.cwd(), out);
+    const id = extractId(idOrUrl);
+    if (quiet) {
+        console.log("\nPulling data source schema…");
+    }
+    else {
+        console.log(`\nResolving ${idOrUrl}…\n`);
+    }
+    const result = fetchSchema(id, quiet);
+    const entry = {
+        name: result.name,
+        properties: result.properties,
+    };
+    // Read existing manifest or start fresh. The entry for `key` is fully
+    // replaced so stale properties are automatically removed.
+    let manifest;
+    if (existsSync(outPath)) {
+        try {
+            const existing = JSON.parse(readFileSync(outPath, "utf-8"));
+            manifest = { version: 1, dataSources: existing.dataSources ?? {} };
+        }
+        catch {
+            manifest = { version: 1, dataSources: {} };
+        }
+    }
+    else {
+        manifest = { version: 1, dataSources: {} };
+    }
+    manifest.dataSources[key] = entry;
+    const json = JSON.stringify(manifest, null, "\t") + "\n";
+    if (dryRun) {
+        console.log(json);
+        return;
+    }
+    writeFileSync(outPath, json);
+    // Stash the resolved data-source ID in .notion/target.json so `connect`
+    // can wire the block without the user re-typing it. Don't touch block_id
+    // or property_ids_by_key — init seeds block_id at scaffold time, and
+    // `connect` fills in property_ids_by_key.
+    const existingTarget = readTarget();
+    const existingEntry = existingTarget?.data_sources[key];
+    const merged = mergeTarget(existingTarget, {
+        data_sources: {
+            [key]: {
+                data_source_id: result.dataSourceId,
+                property_ids_by_key: existingEntry?.property_ids_by_key ?? {},
+            },
+        },
+    });
+    writeTarget(merged);
+    const count = Object.keys(result.properties).length;
+    if (quiet) {
+        console.log(`Found database "${result.name}" (${count} properties)`);
+        return;
+    }
+    console.log(`\n✓ Updated ${out} (key: "${key}")\n`);
+    console.log(`  → recorded data_source_id in .notion/target.json (${key})`);
+    console.log(`  ${count} properties from "${result.name}":`);
+    for (const [k, p] of Object.entries(result.properties)) {
+        console.log(`    ${k}: ${p.name} (${p.type})`);
+    }
+    console.log("");
+}

package/bin/cli/target.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve as resolvePath } from "node:path";
+export const TARGET_PATH = ".notion/target.json";
+function defaultTarget() {
+    return { env: "production", block_id: [], data_sources: {} };
+}
+export function resolveTargetPath(cwd = process.cwd()) {
+    return resolvePath(cwd, TARGET_PATH);
+}
+export function readTarget(cwd = process.cwd()) {
+    const path = resolveTargetPath(cwd);
+    if (!existsSync(path)) {
+        return null;
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error: failed to read ${TARGET_PATH}: ${message}\n  Check file permissions.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Error: ${TARGET_PATH} contains invalid JSON.\n  Fix the syntax or delete the file to regenerate it with 'ncblock connect'.`);
+    }
+    return normalizeTarget(parsed);
+}
+export function writeTarget(config, cwd = process.cwd()) {
+    const path = resolveTargetPath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(config, null, "\t") + "\n");
+}
+function normalizeTarget(value) {
+    if (!isRecord(value)) {
+        throw new Error(`Error: ${TARGET_PATH} must be a JSON object.\n  Delete the file to regenerate it with 'ncblock connect'.`);
+    }
+    const env = typeof value.env === "string" ? value.env : "production";
+    const block_id = [];
+    if (Array.isArray(value.block_id)) {
+        for (const entry of value.block_id) {
+            if (typeof entry === "string" && entry.length > 0) {
+                block_id.push(entry);
+            }
+        }
+    }
+    else if (typeof value.block_id === "string" && value.block_id.length > 0) {
+        block_id.push(value.block_id);
+    }
+    const data_sources = {};
+    if (isRecord(value.data_sources)) {
+        for (const [key, ds] of Object.entries(value.data_sources)) {
+            if (!isRecord(ds) || typeof ds.data_source_id !== "string") {
+                continue;
+            }
+            const property_ids_by_key = {};
+            if (isRecord(ds.property_ids_by_key)) {
+                for (const [k, v] of Object.entries(ds.property_ids_by_key)) {
+                    if (typeof v === "string") {
+                        property_ids_by_key[k] = v;
+                    }
+                }
+            }
+            data_sources[key] = {
+                data_source_id: ds.data_source_id,
+                property_ids_by_key,
+            };
+        }
+    }
+    return { env, block_id, data_sources };
+}
+/**
+ * Merge a new partial target into the existing one. Block IDs from `incoming`
+ * are appended (de-duplicated). Data source bindings replace any existing
+ * binding for matching keys; unrelated keys are preserved.
+ */
+export function mergeTarget(existing, incoming) {
+    const base = existing ?? defaultTarget();
+    const env = incoming.env ?? base.env;
+    const blockIds = new Set(base.block_id);
+    for (const id of incoming.block_id ?? []) {
+        blockIds.add(id);
+    }
+    const data_sources = {
+        ...base.data_sources,
+        ...(incoming.data_sources ?? {}),
+    };
+    return { env, block_id: [...blockIds], data_sources };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/bin/src/bridge/dataSources/propertySchema.js

@@ -0,0 +1,148 @@
+import * as v from "valibot";
+/**
+ * Hex-token identifiers for Notion's named colors. Mirrors the public API's
+ * `select.options[].color` enum
+ * (https://developers.notion.com/reference/property-object#select).
+ */
+export const notionPropertyColorSchema = v.picklist([
+    "default",
+    "gray",
+    "brown",
+    "orange",
+    "yellow",
+    "green",
+    "blue",
+    "purple",
+    "pink",
+    "red",
+    "gray_background",
+    "brown_background",
+    "orange_background",
+    "yellow_background",
+    "green_background",
+    "blue_background",
+    "purple_background",
+    "pink_background",
+    "red_background",
+    "default_background",
+]);
+export const notionPropertyOptionSchema = v.object({
+    id: v.string(),
+    name: v.string(),
+    color: v.optional(notionPropertyColorSchema),
+    description: v.optional(v.string()),
+});
+export const notionStatusGroupSchema = v.object({
+    id: v.string(),
+    name: v.string(),
+    color: v.optional(notionPropertyColorSchema),
+    option_ids: v.array(v.string()),
+});
+export const notionDualPropertySchema = v.object({
+    synced_property_id: v.string(),
+    synced_property_name: v.string(),
+});
+const baseProp = v.object({
+    name: v.string(),
+    description: v.optional(v.string()),
+});
+/**
+ * Every Notion property type the bridge speaks, in a single readable list.
+ * Mirrors the Notion public API
+ * [property object](https://developers.notion.com/reference/property-object)
+ * type field. Internal-only types (`button`, `verification`,
+ * `last_visited_time`, `location`) and the four built-ins (`created_time`,
+ * `last_edited_time`, `created_by`, `last_edited_by`) are included under their
+ * bridge-native names.
+ */
+export const NOTION_PROPERTY_TYPES = [
+    "title",
+    "rich_text",
+    "number",
+    "checkbox",
+    "url",
+    "email",
+    "phone_number",
+    "select",
+    "multi_select",
+    "status",
+    "date",
+    "people",
+    "files",
+    "unique_id",
+    "relation",
+    "place",
+    "formula",
+    "rollup",
+    "button",
+    "verification",
+    "last_visited_time",
+    "location",
+    "created_time",
+    "last_edited_time",
+    "created_by",
+    "last_edited_by",
+];
+export const notionPropertyTypeSchema = v.picklist(NOTION_PROPERTY_TYPES);
+/**
+ * Per-property schema as exposed by the host over the custom-block bridge.
+ * The `type` discriminator must be one of {@link NOTION_PROPERTY_TYPES}.
+ */
+export const notionPropertySchemaSchema = v.variant("type", [
+    v.object({ ...baseProp.entries, type: v.literal("title") }),
+    v.object({ ...baseProp.entries, type: v.literal("rich_text") }),
+    v.object({ ...baseProp.entries, type: v.literal("number") }),
+    v.object({ ...baseProp.entries, type: v.literal("checkbox") }),
+    v.object({ ...baseProp.entries, type: v.literal("url") }),
+    v.object({ ...baseProp.entries, type: v.literal("email") }),
+    v.object({ ...baseProp.entries, type: v.literal("phone_number") }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("select"),
+        options: v.array(notionPropertyOptionSchema),
+    }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("multi_select"),
+        options: v.array(notionPropertyOptionSchema),
+    }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("status"),
+        options: v.array(notionPropertyOptionSchema),
+        groups: v.array(notionStatusGroupSchema),
+    }),
+    v.object({ ...baseProp.entries, type: v.literal("date") }),
+    v.object({ ...baseProp.entries, type: v.literal("people") }),
+    v.object({ ...baseProp.entries, type: v.literal("files") }),
+    v.object({ ...baseProp.entries, type: v.literal("unique_id") }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("relation"),
+        data_source_id: v.optional(v.string()),
+        dual_property: v.optional(notionDualPropertySchema),
+    }),
+    v.object({ ...baseProp.entries, type: v.literal("place") }),
+    v.object({ ...baseProp.entries, type: v.literal("formula") }),
+    v.object({ ...baseProp.entries, type: v.literal("rollup") }),
+    // Internal-only types passed through under their bridge-native names.
+    v.object({ ...baseProp.entries, type: v.literal("button") }),
+    v.object({ ...baseProp.entries, type: v.literal("verification") }),
+    v.object({ ...baseProp.entries, type: v.literal("last_visited_time") }),
+    v.object({ ...baseProp.entries, type: v.literal("location") }),
+    // Synthetic built-ins. The host always emits one of each per data source.
+    v.object({ ...baseProp.entries, type: v.literal("created_time") }),
+    v.object({ ...baseProp.entries, type: v.literal("last_edited_time") }),
+    v.object({ ...baseProp.entries, type: v.literal("created_by") }),
+    v.object({ ...baseProp.entries, type: v.literal("last_edited_by") }),
+]);
+/**
+ * The four synthetic built-in property IDs the host always includes in every
+ * data source's `propertySchemasById` and every row's `propertiesById`.
+ */
+export const NOTION_BUILTIN_PROPERTY_IDS = [
+    "created_time",
+    "last_edited_time",
+    "created_by",
+    "last_edited_by",
+];

package/bin/src/bridge/manifest.js

@@ -0,0 +1,40 @@
+import * as v from "valibot";
+import { notionPropertyTypeSchema } from "./dataSources/propertySchema.js";
+/**
+ * User-authored manifest declaring the data sources the custom block expects.
+ * Lives at `custom_blocks.json` in the project root and is forwarded to the host with
+ * the bridge `ready` message so the host can pre-bind data sources, surface
+ * configuration UI, etc. The `notionCustomBlock` Vite plugin from
+ * `@notionhq/custom-blocks/vite` wires the JSON file into the dev server and
+ * the build output.
+ */
+/**
+ * Decorative icon attached to a manifest data source. Mirrors the
+ * `emoji` / `external` icon variants the public Notion API uses, so the host
+ * can render a recognizable affordance next to the slot in setup UI.
+ */
+export const manifestIconSchema = v.variant("type", [
+    v.object({
+        type: v.literal("emoji"),
+        emoji: v.string(),
+    }),
+    v.object({
+        type: v.literal("external"),
+        url: v.string(),
+    }),
+]);
+export const manifestPropertySchema = v.object({
+    name: v.string(),
+    description: v.optional(v.string()),
+    type: notionPropertyTypeSchema,
+});
+export const manifestDataSourceSchema = v.object({
+    name: v.string(),
+    description: v.optional(v.string()),
+    icon: v.optional(manifestIconSchema),
+    properties: v.optional(v.record(v.string(), manifestPropertySchema), {}),
+});
+export const manifestSchema = v.object({
+    version: v.literal(1),
+    dataSources: v.record(v.string(), manifestDataSourceSchema),
+});

package/dist/autoResize.d.ts

@@ -0,0 +1,4 @@
+export declare function autoResize(args: {
+    target: HTMLElement | null | undefined;
+}): () => void;
+//# sourceMappingURL=autoResize.d.ts.map

package/dist/autoResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoResize.d.ts","sourceRoot":"","sources":["../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/autoResize.ts"],"names":[],"mappings":"AAKA,wBAAgB,UAAU,CAAC,IAAI,EAAE;IAChC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAA;CACtC,GAAG,MAAM,IAAI,CA4Eb"}

package/dist/autoResize.js

@@ -0,0 +1,71 @@
+import { customBlockHost } from "./bridge/sandboxClient.js";
+/** Limits host resize messages to 10 per second while preserving the latest height. */
+const AUTO_RESIZE_THROTTLE_MS = 100;
+export function autoResize(args) {
+    const { target } = args;
+    if (target === null || target === undefined) {
+        return () => { };
+    }
+    // Use a leading/trailing throttle: send the first changed height immediately, then retain only
+    // the latest height observed and send it when the throttling period ends.
+    let lastHeightReportedToHost = -1;
+    let pendingHeight;
+    let throttleTimeout;
+    /** Sends a height immediately and records it as the deduplication baseline. */
+    const sendHeightToHost = (height) => {
+        lastHeightReportedToHost = height;
+        customBlockHost.postResize(height);
+    };
+    /** Sends the latest height queued during the throttling period, if one exists. */
+    const flushPendingHeight = () => {
+        if (throttleTimeout !== undefined) {
+            clearTimeout(throttleTimeout);
+            throttleTimeout = undefined;
+        }
+        if (pendingHeight === undefined) {
+            return;
+        }
+        const height = pendingHeight;
+        pendingHeight = undefined;
+        sendHeightToHost(height);
+        throttleTimeout = setTimeout(flushPendingHeight, AUTO_RESIZE_THROTTLE_MS);
+    };
+    /** Measures the target and either sends, queues, or deduplicates its height. */
+    const measureAndScheduleResize = () => {
+        const next = Math.ceil(target.getBoundingClientRect().height);
+        if (next === lastHeightReportedToHost) {
+            // The height has not changed since the last measurement. Do nothing.
+            pendingHeight = undefined;
+            return;
+        }
+        if (throttleTimeout !== undefined) {
+            // The height has changed since the last measurement, but the throttling period has not
+            // ended. Queue the new height for later.
+            pendingHeight = next;
+            return;
+        }
+        // The height has changed since the last measurement and the throttling period has ended.
+        // Send the new height immediately and start a new throttling period.
+        sendHeightToHost(next);
+        throttleTimeout = setTimeout(flushPendingHeight, AUTO_RESIZE_THROTTLE_MS);
+    };
+    // Measure the initial height and schedule the first throttling period.
+    measureAndScheduleResize();
+    // If the ResizeObserver API is not available, return a function that cleans up the throttling
+    // period started by the initial measurement.
+    if (typeof ResizeObserver === "undefined") {
+        return () => {
+            clearTimeout(throttleTimeout);
+            throttleTimeout = undefined;
+        };
+    }
+    // Observe the target and schedule subsequent measurements and throttling periods.
+    const observer = new ResizeObserver(measureAndScheduleResize);
+    observer.observe(target);
+    // Clean up the observer and the throttling period.
+    return () => {
+        observer.disconnect();
+        clearTimeout(throttleTimeout);
+        throttleTimeout = undefined;
+    };
+}

package/dist/bridge/SandboxBridge.d.ts

@@ -0,0 +1,92 @@
+import type { CreatePageInput, CreatePageResult, GetPageResult, GetUserResult, ListUsersInput, ListUsersResult, NotionPageId, NotionUserId, UpdatePageInput, UpdatePageResult, UseDataSourceOptions } from "../types.js";
+import type { NotionDataSource } from "./dataSources/dataSource.js";
+import type { NotionDataSourcePageUpdateInput, NotionDataSourcePageUpdateResult } from "./dataSources/dataSourcePage.js";
+import { type CustomBlockHostState } from "./hostState.js";
+import type { ManifestLoadResult } from "./loadManifest.js";
+import type { CustomBlockManifest } from "./manifest.js";
+import { type InitMessage } from "./messages/init.js";
+/**
+ * Used to ensure that the host and client are using the same version of the bridge protocol. A
+ * single host needs to support multiple custom blocks built with different versions of the bridge
+ * protocol. Increment this number any time a breaking change is made to the bridge protocol.
+ */
+export declare const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 2;
+/**
+ * A single entry in the bridge message log. Kept intentionally plain so the log
+ * is copy-pasteable to a local coding agent without needing extra context.
+ */
+export type MessageLogEntry = {
+    timestamp: string;
+    direction: "sent" | "received";
+    data: unknown;
+};
+export declare class SandboxBridge {
+    private hostState;
+    private listeners;
+    private messageLog;
+    private messageLogListeners;
+    private nextRequestId;
+    private readonly pendingCreatePage;
+    private readonly pendingGetPage;
+    private readonly pendingGetUser;
+    private readonly pendingListUsers;
+    private readonly pendingUpdatePage;
+    private hasSentReady;
+    private latestDataSourceBindings;
+    private resolveInit;
+    private rejectInit;
+    private readonly initMessage;
+    private manifest;
+    constructor();
+    private static MAX_LOG_ENTRIES;
+    private logMessage;
+    getMessageLog(): readonly MessageLogEntry[];
+    subscribeToMessageLog(listener: () => void): () => boolean;
+    awaitInit(signal?: AbortSignal): Promise<InitMessage>;
+    sendReady(manifestResult: ManifestLoadResult): void;
+    private postToHost;
+    private notify;
+    private handleMessage;
+    subscribe(listener: () => void): () => boolean;
+    getHostState(): CustomBlockHostState;
+    /**
+     * The author-declared manifest loaded from `custom_blocks.json` and forwarded
+     * to the host in `ready`. `null` when it failed to load/parse and the host
+     * should reject init via `ready.status: "error"`. Static for the lifetime
+     * of the sandbox.
+     */
+    getManifest(): CustomBlockManifest | null;
+    /**
+     * Apply an `init` payload as if it had arrived from the host. Lets callers
+     * seed the bridge directly (e.g. the React provider's standalone preview
+     * fallback) without going through `postMessage`. The bridge stays unaware
+     * of why it's being seeded.
+     */
+    setMockState(message: InitMessage): void;
+    private applyInit;
+    queryDataSource(key: string, options?: UseDataSourceOptions): void;
+    private setDataSourceQueryError;
+    postResize(height: number): void;
+    createPage(input: CreatePageInput): Promise<CreatePageResult>;
+    getPage(pageId: NotionPageId): Promise<GetPageResult>;
+    getUser(userId: NotionUserId): Promise<GetUserResult>;
+    listUsers(input?: ListUsersInput): Promise<ListUsersResult>;
+    updatePage(input: UpdatePageInput): Promise<UpdatePageResult>;
+    /**
+     * Updates a page on a known data source, resolving any property keys against the data source's
+     * `propertyIdsByKey` before sending the bridge message. Used by the per-row `update` callback
+     * returned from {@link getDataSourceQueryView}.
+     */
+    updateDataSourcePage(args: {
+        dataSource: NotionDataSource;
+        pageId: NotionPageId;
+        input: NotionDataSourcePageUpdateInput;
+    }): Promise<NotionDataSourcePageUpdateResult>;
+    /**
+     * Translates the public `CreatePageInput["parent"]` into the bridge-native
+     * `CreatePageMessageParent`. The `data_source_key` variant is resolved sandbox-side against
+     * the data source mapping the host delivered in `init` / `dataSourcesChanged`.
+     */
+    private resolveCreatePageParent;
+}
+//# sourceMappingURL=SandboxBridge.d.ts.map

package/dist/bridge/SandboxBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxBridge.d.ts","sourceRoot":"","sources":["../../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/bridge/SandboxBridge.ts"],"names":[],"mappings":"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"}