@happyvertical/smrt-reports 0.55.24 → 0.56.1

package/dist/svelte/messages.d.ts

@@ -0,0 +1,72 @@
+export declare const M: {
+    readonly 'reports.title': "reports.title";
+    readonly 'reports.only_mine': "reports.only_mine";
+    readonly 'reports.archived': "reports.archived";
+    readonly 'reports.archive': "reports.archive";
+    readonly 'reports.unarchive': "reports.unarchive";
+    readonly 'reports.loading': "reports.loading";
+    readonly 'reports.running': "reports.running";
+    readonly 'reports.empty': "reports.empty";
+    readonly 'reports.no_rows': "reports.no_rows";
+    readonly 'reports.unavailable': "reports.unavailable";
+    readonly 'reports.error': "reports.error";
+    readonly 'reports.denied': "reports.denied";
+    readonly 'reports.invalid': "reports.invalid";
+    readonly 'reports.retry': "reports.retry";
+    readonly 'reports.rerun': "reports.rerun";
+    readonly 'reports.table': "reports.table";
+    readonly 'reports.chart': "reports.chart";
+    readonly 'reports.source': "reports.source";
+    readonly 'reports.author': "reports.author";
+    readonly 'reports.last_run': "reports.last_run";
+    readonly 'reports.never_run': "reports.never_run";
+    readonly 'reports.truncated': "reports.truncated";
+    readonly 'reports.yes': "reports.yes";
+    readonly 'reports.no': "reports.no";
+    readonly 'reports.select_report': "reports.select_report";
+    readonly 'reports.select_measure': "reports.select_measure";
+    readonly 'reports.choose_report': "reports.choose_report";
+    readonly 'reports.choose_measure': "reports.choose_measure";
+    readonly 'reports.select_dimension': "reports.select_dimension";
+    readonly 'reports.choose_dimension': "reports.choose_dimension";
+    readonly 'reports.options_invalid': "reports.options_invalid";
+    readonly 'reports.cancel': "reports.cancel";
+    readonly 'reports.save': "reports.save";
+    readonly 'reports.confirm_title': "reports.confirm_title";
+    readonly 'reports.saved': "reports.saved";
+    readonly 'reports.declined': "reports.declined";
+    readonly 'reports.groupings': "reports.groupings";
+    readonly 'reports.measures': "reports.measures";
+    readonly 'reports.filters': "reports.filters";
+    readonly 'reports.having': "reports.having";
+    readonly 'reports.none': "reports.none";
+    readonly 'reports.rows': "reports.rows";
+    readonly 'reports.saving': "reports.saving";
+    readonly 'reports.approve': "reports.approve";
+    readonly 'reports.decline': "reports.decline";
+    readonly 'reports.aggregate.count': "reports.aggregate.count";
+    readonly 'reports.aggregate.countDistinct': "reports.aggregate.countDistinct";
+    readonly 'reports.aggregate.sum': "reports.aggregate.sum";
+    readonly 'reports.aggregate.avg': "reports.aggregate.avg";
+    readonly 'reports.aggregate.min': "reports.aggregate.min";
+    readonly 'reports.aggregate.max': "reports.aggregate.max";
+    readonly 'reports.operator.eq': "reports.operator.eq";
+    readonly 'reports.operator.ne': "reports.operator.ne";
+    readonly 'reports.operator.gt': "reports.operator.gt";
+    readonly 'reports.operator.gte': "reports.operator.gte";
+    readonly 'reports.operator.lt': "reports.operator.lt";
+    readonly 'reports.operator.lte': "reports.operator.lte";
+    readonly 'reports.operator.in': "reports.operator.in";
+    readonly 'reports.operator.notIn': "reports.operator.notIn";
+    readonly 'reports.operator.contains': "reports.operator.contains";
+    readonly 'reports.operator.isNull': "reports.operator.isNull";
+    readonly 'reports.operator.isNotNull': "reports.operator.isNotNull";
+    readonly 'reports.bucket.minute': "reports.bucket.minute";
+    readonly 'reports.bucket.hour': "reports.bucket.hour";
+    readonly 'reports.bucket.day': "reports.bucket.day";
+    readonly 'reports.bucket.week': "reports.bucket.week";
+    readonly 'reports.bucket.month': "reports.bucket.month";
+    readonly 'reports.bucket.quarter': "reports.bucket.quarter";
+    readonly 'reports.bucket.year': "reports.bucket.year";
+};
+//# sourceMappingURL=messages.d.ts.map

package/dist/svelte/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/svelte/messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEZ,CAAC"}

package/dist/svelte/messages.js

@@ -0,0 +1,72 @@
+import { defineMessages } from '@happyvertical/smrt-ui/i18n';
+export const M = defineMessages({
+    'reports.title': 'Reports',
+    'reports.only_mine': 'Only mine',
+    'reports.archived': 'Show archived reports',
+    'reports.archive': 'Archive',
+    'reports.unarchive': 'Unarchive',
+    'reports.loading': 'Loading reports…',
+    'reports.running': 'Running report…',
+    'reports.empty': 'No saved reports. Ask the assistant to create a report, then approve its proposal.',
+    'reports.no_rows': 'No results match this report.',
+    'reports.unavailable': 'Reports are unavailable because this host has no server.',
+    'reports.error': 'The report request failed. Please try again.',
+    'reports.denied': 'You do not have permission to read this report or one of its fields.',
+    'reports.invalid': 'The report returned an invalid result.',
+    'reports.retry': 'Try again',
+    'reports.rerun': 'Re-run',
+    'reports.table': 'Table view',
+    'reports.chart': 'Chart view',
+    'reports.source': 'Source',
+    'reports.author': 'Author',
+    'reports.last_run': 'Last run: {time}',
+    'reports.never_run': 'No recent run',
+    'reports.truncated': 'Showing a bounded sample; more rows are available.',
+    'reports.yes': 'Yes',
+    'reports.no': 'No',
+    'reports.select_report': 'Report',
+    'reports.select_measure': 'Measure',
+    'reports.choose_report': 'Choose a saved report',
+    'reports.choose_measure': 'Choose a measure',
+    'reports.select_dimension': 'Dimension',
+    'reports.choose_dimension': 'Choose a dimension',
+    'reports.options_invalid': 'Choose a report and measure before saving.',
+    'reports.cancel': 'Cancel',
+    'reports.save': 'Save',
+    'reports.confirm_title': 'Review report proposal',
+    'reports.saved': 'Report saved.',
+    'reports.declined': 'Report declined. Nothing was saved.',
+    'reports.groupings': 'Group by',
+    'reports.measures': 'Measures',
+    'reports.filters': 'Filters',
+    'reports.having': 'Measure filters',
+    'reports.none': 'None',
+    'reports.rows': 'rows',
+    'reports.saving': 'Saving…',
+    'reports.approve': 'Approve',
+    'reports.decline': 'Decline',
+    'reports.aggregate.count': 'Count of {field}',
+    'reports.aggregate.countDistinct': 'Distinct count of {field}',
+    'reports.aggregate.sum': 'Sum of {field}',
+    'reports.aggregate.avg': 'Average of {field}',
+    'reports.aggregate.min': 'Minimum of {field}',
+    'reports.aggregate.max': 'Maximum of {field}',
+    'reports.operator.eq': 'equals',
+    'reports.operator.ne': 'does not equal',
+    'reports.operator.gt': 'is greater than',
+    'reports.operator.gte': 'is at least',
+    'reports.operator.lt': 'is less than',
+    'reports.operator.lte': 'is at most',
+    'reports.operator.in': 'is one of',
+    'reports.operator.notIn': 'is not one of',
+    'reports.operator.contains': 'contains',
+    'reports.operator.isNull': 'is empty',
+    'reports.operator.isNotNull': 'is not empty',
+    'reports.bucket.minute': 'Minute',
+    'reports.bucket.hour': 'Hour',
+    'reports.bucket.day': 'Day',
+    'reports.bucket.week': 'Week',
+    'reports.bucket.month': 'Month',
+    'reports.bucket.quarter': 'Quarter',
+    'reports.bucket.year': 'Year',
+});

package/dist/svelte/playground.d.ts

@@ -0,0 +1,132 @@
+declare const _default: {
+    packageName: string;
+    displayName: string;
+    description: string;
+    entries: ({
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./SavedReports.svelte").Props, {}, "">>;
+        props: {
+            client: import("./types.js").RuntimeReportsClient;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportDetail.svelte").Props, {}, "">>;
+        props: {
+            id: string;
+            client: import("./types.js").RuntimeReportsClient;
+            locale: string;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportConfirmation.svelte").Props, {}, "">>;
+        props: {
+            proposal: import("./types.js").RuntimeReportProposal;
+            confirm: () => Promise<import("./types.js").SavedRuntimeReport>;
+            client?: undefined;
+            id?: undefined;
+            locale?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportPicker.svelte").Props, {}, "">>;
+        props: {
+            client: import("./types.js").RuntimeReportsClient;
+            reportId: string;
+            measure: string;
+            dimension: string;
+            onchange: () => void;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./RuntimeReportsRoute.svelte").Props, {}, "">>;
+        props: {
+            serverAvailable: boolean;
+            client?: undefined;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportResult.svelte").Props, {}, "">>;
+        props: {
+            result: {
+                rows: never[];
+                rowCount: number;
+                version: 1;
+                specHash: string;
+                title: string;
+                columns: import("../runtime-compiler.js").RuntimeReportColumn[];
+                truncated: boolean;
+                ranAt: string;
+                chart: import("../runtime-spec.js").RuntimeReportChart;
+            };
+            client?: undefined;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+        };
+        order: number;
+    })[];
+};
+export default _default;
+//# sourceMappingURL=playground.d.ts.map

package/dist/svelte/playground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../../src/svelte/playground.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wBAkEE"}

package/dist/svelte/playground.js

@@ -0,0 +1,62 @@
+import { client, proposal, result, saved } from './preview-data.js';
+export default {
+    packageName: '@happyvertical/smrt-reports',
+    displayName: 'Reports',
+    description: 'Saved runtime reports and live results.',
+    entries: [
+        {
+            id: 'saved-reports',
+            title: 'Saved reports',
+            description: 'Shared reports, author filter, and archive controls.',
+            loadComponent: () => import('./SavedReports.svelte').then((m) => m.default),
+            props: { client: client() },
+            order: 1,
+        },
+        {
+            id: 'report-detail',
+            title: 'Report detail',
+            description: 'Money values with chart and table views.',
+            loadComponent: () => import('./ReportDetail.svelte').then((m) => m.default),
+            props: { id: saved.id, client: client(), locale: 'en-US' },
+            order: 2,
+        },
+        {
+            id: 'report-confirmation',
+            title: 'Report confirmation',
+            description: 'Review a bounded proposal before saving.',
+            loadComponent: () => import('./ReportConfirmation.svelte').then((m) => m.default),
+            props: { proposal, confirm: async () => saved },
+            order: 3,
+        },
+        {
+            id: 'report-picker',
+            title: 'Report picker',
+            description: 'Choose a saved report and its measure.',
+            loadComponent: () => import('./ReportPicker.svelte').then((m) => m.default),
+            props: {
+                client: client(),
+                reportId: saved.id,
+                measure: 'total',
+                dimension: 'region',
+                onchange: () => { },
+            },
+            order: 4,
+        },
+        {
+            id: 'reports-unavailable',
+            title: 'Reports unavailable',
+            description: 'Static hosts do not make server requests.',
+            loadComponent: () => import('./RuntimeReportsRoute.svelte').then((m) => m.default),
+            props: { serverAvailable: false },
+            order: 5,
+        },
+        {
+            id: 'report-empty',
+            title: 'Empty report',
+            description: 'A valid report with no matching rows.',
+            loadComponent: () => import('./ReportResult.svelte').then((m) => m.default),
+            props: { result: { ...result, rows: [], rowCount: 0 } },
+            order: 6,
+        },
+    ],
+};

package/dist/svelte/preview-data.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeReportProposal, RuntimeReportResult, RuntimeReportSpec, RuntimeReportsClient, SavedRuntimeReport } from './types.js';
+export declare const spec: RuntimeReportSpec;
+export declare const result: RuntimeReportResult;
+export declare const saved: SavedRuntimeReport;
+export declare const proposal: RuntimeReportProposal;
+export declare function client(overrides?: Partial<RuntimeReportsClient>): RuntimeReportsClient;
+//# sourceMappingURL=preview-data.d.ts.map

package/dist/svelte/preview-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-data.d.ts","sourceRoot":"","sources":["../../src/svelte/preview-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,IAAI,EAAE,iBAWlB,CAAC;AACF,eAAO,MAAM,MAAM,EAAE,mBAmBpB,CAAC;AACF,eAAO,MAAM,KAAK,EAAE,kBAQnB,CAAC;AACF,eAAO,MAAM,QAAQ,EAAE,qBAOtB,CAAC;AACF,wBAAgB,MAAM,CACpB,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,oBAAoB,CAStB"}

package/dist/svelte/preview-data.js

@@ -0,0 +1,59 @@
+export const spec = {
+    version: 1,
+    title: 'Sales by region',
+    source: 'sales',
+    dimensions: [{ field: 'region', as: 'region' }],
+    measures: [{ fn: 'sum', field: 'amount', as: 'total' }],
+    filters: [],
+    having: [],
+    sort: [],
+    limit: 100,
+    chart: { type: 'bar', x: 'region', y: ['total'] },
+};
+export const result = {
+    version: 1,
+    specHash: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    title: spec.title,
+    columns: [
+        { id: 'region', label: 'Region', role: 'dimension', type: 'string' },
+        {
+            id: 'total',
+            label: 'Total',
+            role: 'measure',
+            type: 'integer',
+            format: 'money',
+        },
+    ],
+    rows: [{ region: 'West', total: 12345 }],
+    rowCount: 1,
+    truncated: false,
+    ranAt: '2026-10-13T12:00:00Z',
+    chart: spec.chart,
+};
+export const saved = {
+    id: 'report-1',
+    title: spec.title,
+    sourceId: 'sales',
+    createdByUserId: 'alice',
+    status: 'active',
+    spec,
+    canArchive: true,
+};
+export const proposal = {
+    status: 'awaiting_confirmation',
+    specHash: result.specHash,
+    spec,
+    preview: result,
+    sourceLabel: 'Sales',
+    confirmPath: '/api/_reports/runtime/confirm',
+};
+export function client(overrides = {}) {
+    return {
+        list: async () => [saved],
+        get: async () => saved,
+        run: async () => result,
+        archive: async () => { },
+        confirm: async () => saved,
+        ...overrides,
+    };
+}

package/dist/svelte/result.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeReportResult } from './types.js';
+export declare function reportError(error: unknown): 'reports.denied' | 'reports.invalid' | 'reports.error';
+/** Validate untrusted result data before formatting, including integer precision. */
+export declare function validReportResult(value: unknown): value is RuntimeReportResult;
+export declare function reportCell(value: unknown, column: RuntimeReportResult['columns'][number], locale: string, currency: string): string;
+/** Narrow the UI projection; canonical spec validation remains server-owned. */
+export declare function validReportProposal(value: unknown): value is import('./types.js').RuntimeReportProposal;
+//# sourceMappingURL=result.d.ts.map

package/dist/svelte/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/svelte/result.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,iBAAiB,GAAG,eAAe,CAQxD;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAkD9B;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EAC9C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAcR;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,OAAO,YAAY,EAAE,qBAAqB,CA8BrD"}

package/dist/svelte/result.js

@@ -0,0 +1,99 @@
+import { formatWidgetValue } from '@happyvertical/smrt-ui/charts/format';
+import { validRuntimeReportSpec } from './spec.js';
+export function reportError(error) {
+    if (error && typeof error === 'object') {
+        const e = error;
+        if (e.status === 401 || e.status === 403 || e.code === 'unknown_field')
+            return 'reports.denied';
+        if (e.code === 'invalid_result')
+            return 'reports.invalid';
+    }
+    return 'reports.error';
+}
+/** Validate untrusted result data before formatting, including integer precision. */
+export function validReportResult(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const r = value;
+    return (r.version === 1 &&
+        typeof r.title === 'string' &&
+        typeof r.specHash === 'string' &&
+        typeof r.ranAt === 'string' &&
+        typeof r.truncated === 'boolean' &&
+        Array.isArray(r.columns) &&
+        r.columns.length > 0 &&
+        r.columns.length <= 10 &&
+        new Set(r.columns.map((c) => c?.id)).size === r.columns.length &&
+        r.columns.every((c) => c &&
+            typeof c.id === 'string' &&
+            typeof c.label === 'string' &&
+            ['dimension', 'measure'].includes(c.role) &&
+            ['string', 'integer', 'decimal', 'boolean', 'datetime', 'id'].includes(c.type)) &&
+        Array.isArray(r.rows) &&
+        r.rows.length <= 1000 &&
+        r.rowCount === r.rows.length &&
+        r.rows.every((row) => row &&
+            typeof row === 'object' &&
+            r.columns.every((c) => {
+                const v = row[c.id];
+                if (v === null)
+                    return true;
+                if (c.type === 'integer')
+                    return typeof v === 'number' && Number.isSafeInteger(v);
+                if (c.type === 'decimal')
+                    return typeof v === 'number' && Number.isFinite(v);
+                if (c.type === 'boolean')
+                    return typeof v === 'boolean';
+                return typeof v === 'string';
+            })) &&
+        !!r.chart &&
+        ['bar', 'line', 'table', 'pie', 'stat'].includes(r.chart.type) &&
+        (r.chart.y === undefined ||
+            (Array.isArray(r.chart.y) &&
+                r.chart.y.every((id) => r.columns.some((c) => c.id === id && c.role === 'measure')))) &&
+        (r.chart.x === undefined || r.columns.some((c) => c.id === r.chart.x)));
+}
+export function reportCell(value, column, locale, currency) {
+    if (value === null || value === undefined)
+        return '–';
+    if (typeof value === 'number')
+        return formatWidgetValue(value, {
+            format: column.format === 'money'
+                ? 'money'
+                : column.type === 'integer'
+                    ? 'integer'
+                    : 'decimal',
+            locale,
+            currency,
+        });
+    return String(value);
+}
+/** Narrow the UI projection; canonical spec validation remains server-owned. */
+export function validReportProposal(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const p = value;
+    if (p.status !== 'awaiting_confirmation' ||
+        typeof p.specHash !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(p.specHash) ||
+        typeof p.sourceLabel !== 'string' ||
+        p.sourceLabel.length < 1 ||
+        p.sourceLabel.length > 120 ||
+        typeof p.confirmPath !== 'string' ||
+        p.confirmPath.length > 2048 ||
+        !p.confirmPath.startsWith('/') ||
+        p.confirmPath.startsWith('//') ||
+        !validReportResult(p.preview) ||
+        p.preview.specHash !== p.specHash ||
+        !p.spec)
+        return false;
+    if (!validRuntimeReportSpec(p.spec) || p.preview.title !== p.spec.title)
+        return false;
+    const roles = new Map([
+        ...p.spec.dimensions.map((entry) => [entry.as, 'dimension']),
+        ...p.spec.measures.map((entry) => [entry.as, 'measure']),
+    ]);
+    return (p.preview.columns.length === roles.size &&
+        p.preview.columns.every((column) => roles.get(column.id) === column.role) &&
+        JSON.stringify(p.preview.chart) === JSON.stringify(p.spec.chart));
+}

package/dist/svelte/spec.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeReportSpec } from './types.js';
+/** Browser-safe validation of the server's already-normalized closed grammar. */
+export declare function validRuntimeReportSpec(value: unknown): value is RuntimeReportSpec;
+export declare function runtimeReportSpecFromWire(value: unknown): RuntimeReportSpec | null;
+//# sourceMappingURL=spec.d.ts.map

package/dist/svelte/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/svelte/spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA+JpD,iFAAiF;AACjF,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CA4I5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,IAAI,CAW1B"}