react-semaphor 0.1.543 → 0.1.545

package/dist/types/shared/dashboard-authoring/filter-model/filter-definitions.d.ts

@@ -0,0 +1,29 @@
+import { TFilter } from '../../../components/surfboard/filter/types.js';
+import { NormalizedFilterDashboardInput, TDashboard } from '../../../lib/types/common-types.js';
+import { FilterInputEntry } from './read-dashboard-filter-model.js';
+/** One definition per filter input, in model order. The same array for the same dashboard object. */
+export declare function listDashboardFilterDefinitions(dashboard: TDashboard): readonly TFilter[];
+/** The dashboard's Global Date filter, whichever input holds it. */
+export declare function getDashboardGlobalDateFilter(dashboard: TDashboard): TFilter | undefined;
+/**
+ * The filter inputs the tab-presence rule places on a tab (M2), in model
+ * order: what the tab's filter bar shows. `sheetKind` overrides the tab's
+ * own kind. None for an unknown tab.
+ */
+export declare function listDashboardFilterInputsOnTab(dashboard: TDashboard, sheetId: string | null | undefined, sheetKind?: 'dashboard' | 'document'): readonly FilterInputEntry[];
+/**
+ * A filter hidden from the toolbar and not attached to a visual: a toolbar
+ * filter's `hide`, or an input placed `hidden` (OF-D14). The edit-mode strip
+ * of hidden filters lists these.
+ */
+export declare function isHiddenFilterInput(input: NormalizedFilterDashboardInput): boolean;
+/**
+ * Every filter definition the stored template holds, as stored: toolbar
+ * filters, stored inputs' filters and prototype Document inputs' filters,
+ * rejected inputs included (the model leaves those out). The objects
+ * themselves, so a writer of the stored shape (a migration's remap, a demo
+ * copy) rewrites them in place on its own copy, and a reader that must see
+ * every stored definition (the connections a migration maps) sees what the
+ * remap writes (one filter model P4b-02 (f)).
+ */
+export declare function listStoredFilterDefinitions(dashboard: TDashboard): TFilter[];

package/dist/types/shared/dashboard-authoring/filter-model/filter-values.d.ts

@@ -0,0 +1,58 @@
+import { TFilter, TFilterValue } from '../../../components/surfboard/filter/types.js';
+import { DashboardInputValues, NormalizedFilterDashboardInput, TDashboard } from '../../../lib/types/common-types.js';
+import { CalendarContext } from '../../report-runtime-context/index.js';
+import { DashboardInputRuntimeTarget } from '../../../lib/dashboard-inputs/dashboard-input-values.js';
+import { DashboardInputRuntimeValues } from '../../../lib/dashboard-inputs/resolve-dashboard-input-context.js';
+/**
+ * M5, the filter value adapters (one filter model SPEC 4.7): they move values
+ * between the old filter value list, keyed by `filterId`, and input slots.
+ * They decide no precedence.
+ */
+/** A host filter default: a full filter value, or the short `{ filterId, values }` embed form. */
+export type HostFilterValue = TFilterValue | {
+    readonly filterId: string;
+    readonly values: string[] | number[];
+};
+/**
+ * A host value as a filter value of this definition (today's hydration rule).
+ * The short embed form names no operation: it takes the filter's own, so the
+ * slot passes the input's validation (ledger P4a-03).
+ */
+export declare function hostFilterValueFor(filter: TFilter, hostValue: HostFilterValue, calendar: CalendarContext | null | undefined): TFilterValue;
+/**
+ * Host overlay in: each value goes to the input owning its `filterId`, as a
+ * runtime slot over saved defaults. A `shared` input gets one slot; a
+ * `perSheet` input gets one on every tab the input is on (a host default is
+ * dashboard-wide, as today). A value whose `filterId` owns no input, or
+ * whose input holds one value per card or section, is dropped and listed.
+ * The values that own no input are also returned as they were listed: the
+ * caller decides whether they are ad-hoc values (SPEC 5.8, 5.9).
+ */
+export declare function hostFilterValuesToSlots(dashboard: TDashboard, values: readonly HostFilterValue[] | undefined, options: {
+    calendar: CalendarContext | null | undefined;
+}): {
+    slots: DashboardInputValues;
+    adHocFilterValues: TFilterValue[];
+    droppedFilterIds: string[];
+};
+/**
+ * List out, tab-wide: each filter shown on this tab with its effective value
+ * (the inputs the tab-presence rule places on it, in model order, each
+ * through the hydration owner), followed by the tab's ad-hoc values. Inputs
+ * with no value, or cleared, are left out. Used by `onFilterValuesChange`,
+ * captures and every reader that reports a tab's filters.
+ */
+export declare function readFilterValueList(params: {
+    dashboard: TDashboard;
+    runtimeValues: Pick<DashboardInputRuntimeValues, 'dashboardInputValues'>;
+    adHocFilterValues: readonly TFilterValue[] | undefined;
+    sheetId: string | null | undefined;
+    sheetKind: 'dashboard' | 'document';
+    calendar: CalendarContext | null;
+}): TFilterValue[];
+/**
+ * Every runtime target a filter input holds a value at: one for a `shared`
+ * input, each tab it is on for `perSheet`, each card it reaches for
+ * `perCard`, each section it reaches for `perDocumentSection`.
+ */
+export declare function listFilterInputValueTargets(dashboard: TDashboard, input: NormalizedFilterDashboardInput): DashboardInputRuntimeTarget[];

package/dist/types/shared/dashboard-authoring/filter-model/index.d.ts

@@ -0,0 +1,7 @@
+export * from './read-dashboard-filter-model.js';
+export * from './toolbar-filter-reach.js';
+export { foldPrototypeDocumentInputs } from './prototype-document-inputs.js';
+export * from './filter-values.js';
+export * from './filter-definitions.js';
+export * from './ad-hoc-filter-values.js';
+export { upgradeToStoredDashboard } from './stored-dashboard.js';

package/dist/types/shared/dashboard-authoring/filter-model/prototype-document-inputs.d.ts

@@ -0,0 +1,15 @@
+import { DashboardInput, DocumentInputDefinition, TDashboard } from '../../../lib/types/common-types.js';
+/**
+ * The prototype Document input fold (one filter model SPEC 4.3 step 3), moved
+ * unchanged from `document-input-prototype-normalizer.ts`: inputs stored in
+ * `sheet.document.inputs` (the earliest Document shape) become Dashboard
+ * Inputs scoped to their tab, with variable names and control ids aligned as
+ * before. Returns the input dashboard when nothing changes.
+ */
+export declare function foldPrototypeDocumentInputs(dashboard: TDashboard): TDashboard;
+/** The ids of the prototype Document inputs the fold would add (not already stored). */
+export declare function listUnfoldedPrototypeDocumentInputs(dashboard: Pick<TDashboard, 'inputs' | 'sheets'>): Array<{
+    sheetId: string;
+    input: DocumentInputDefinition;
+}>;
+export declare function prototypeDocumentInputToDashboardInput(input: DocumentInputDefinition, sheetId: string): DashboardInput;

package/dist/types/shared/dashboard-authoring/filter-model/read-dashboard-filter-model.d.ts

@@ -0,0 +1,78 @@
+import { TFilter } from '../../../components/surfboard/filter/types.js';
+import { DashboardInputScope, DashboardInputValues, EmbeddedFilterDashboardInput, NormalizedFilterDashboardInput, TDashboard } from '../../../lib/types/common-types.js';
+import { DashboardFilterMappingContractIssue } from '../dashboard-filter-mapping-contract.js';
+import { DashboardCardLocation } from '../document-section-cards.js';
+/**
+ * The filter model (one filter model M1): every stored filter shape read as a
+ * filter input. One entry point, `readDashboardFilterModel`, used by the
+ * client runtime and by the server alike. Pure, never throws, memoized per
+ * dashboard object.
+ */
+/** A filter, by its filter id or by an input id (a legacy `compat-filter:` id included). */
+export type FilterRef = {
+    filterId: string;
+} | {
+    inputId: string;
+};
+export type FilterInputOrigin = 'embeddedInput' | 'referencedInput' | 'prototypeDocumentInput' | 'toolbarFilter';
+export type FilterInputEntry = {
+    /** What the runtime consumes; see the runtime view in SPEC 4.3. */
+    input: NormalizedFilterDashboardInput;
+    origin: FilterInputOrigin;
+};
+/** The shared card location plus its tab kind. */
+export type ReachedCard = DashboardCardLocation & {
+    sheetKind: 'dashboard' | 'document';
+};
+export type FilterModelIssueCode = 'contract' | 'duplicate_filter_owner' | 'compat_id_conflict' | 'duplicate_global_date';
+export type FilterModelIssue = {
+    code: FilterModelIssueCode;
+    /** A customer-safe sentence, in the style of the template validator's messages. */
+    message: string;
+    /** JSON path in the template that was read. */
+    path: string;
+    inputId?: string;
+    filterId?: string;
+    contractIssue?: DashboardFilterMappingContractIssue;
+};
+export type DashboardFilterModel = {
+    /** Accepted filter inputs: stored inputs in stored order, then prototype Document inputs, then toolbar filters. */
+    readonly inputs: readonly FilterInputEntry[];
+    readonly issues: readonly FilterModelIssue[];
+    /** Ids of stored inputs left out because of an issue. */
+    readonly rejectedInputIds: ReadonlySet<string>;
+    readonly globalDateInput: FilterInputEntry | undefined;
+    /** True when `toStoredDashboard()` would change anything. */
+    readonly needsUpgrade: boolean;
+    /** The saved defaults the runtime reads: stored `defaultInputValues` with owned `defaultFilterValues` entries moved in. */
+    readonly defaultInputValues: DashboardInputValues;
+    /**
+     * The variable name today's lift gives every toolbar filter, owned ones
+     * included, in filter order. Inputs named after toolbar filters (dashboard
+     * control compatibility inputs) are named against these, so their aliases
+     * stay what they are today (OF-INV-3).
+     */
+    readonly toolbarFilterVariableNames: readonly string[];
+    /** The owning entry. `{ inputId: 'compat-filter:x' }` resolves to the entry holding filter x, whatever its id. */
+    findFilterInput(ref: FilterRef): FilterInputEntry | undefined;
+    /** Card locations in dashboard order the input reaches (`options.scope` instead of its own when given). */
+    reachedCards(ref: FilterRef, options?: {
+        scope?: DashboardInputScope;
+    }): readonly ReachedCard[];
+    /** The template with every filter as an embedded input. The same object when `needsUpgrade` is false. Throws `FilterModelError` when `issues` is not empty. */
+    toStoredDashboard(): TDashboard;
+};
+export declare class FilterModelError extends Error {
+    readonly issues: readonly FilterModelIssue[];
+    constructor(issues: readonly FilterModelIssue[]);
+}
+/** One message for a persistence error: each issue's `message`, joined by "\n". */
+export declare function formatFilterModelIssues(issues: readonly FilterModelIssue[]): string;
+export declare function readDashboardFilterModel(dashboard: TDashboard): DashboardFilterModel;
+/**
+ * The input fields a toolbar filter's own fields give it (step 4), for a
+ * writer that creates or updates its input before Phase 5. The variable name
+ * is not among them: it depends on the dashboard's other inputs (use the
+ * model's entry).
+ */
+export declare function toolbarFilterInputFields(dashboard: Pick<TDashboard, 'sheets'>, filter: TFilter): Pick<EmbeddedFilterDashboardInput, 'label' | 'scope' | 'presentation' | 'exports'>;

package/dist/types/shared/dashboard-authoring/filter-model/stored-dashboard.d.ts

@@ -0,0 +1,18 @@
+import { TDashboard } from '../../../lib/types/common-types.js';
+/**
+ * A template in the stored shape (one filter model SPEC 5.1, 5.4): every
+ * filter an embedded input. The one upgrade, for the load
+ * (`prepareLoadedDashboard`) and every template write (the app's
+ * `prepareDashboardDocument`).
+ *
+ * The old shape's toolbar list also reserved names that compatibility
+ * aliases (dashboard controls, card controls, card inline filters) were
+ * allocated around; without it those aliases can change (`region3` becomes
+ * `region2`). So alias-based text is first bound to stable input ids against
+ * the template as read, then the model writes the stored shape (OF-INV-3,
+ * ledger P5-11).
+ *
+ * The same object when nothing needs upgrading. Throws `FilterModelError`
+ * when the model reports issues, as `toStoredDashboard()` does.
+ */
+export declare function upgradeToStoredDashboard(dashboard: TDashboard): TDashboard;

package/dist/types/shared/dashboard-authoring/filter-model/toolbar-filter-reach.d.ts

@@ -0,0 +1,23 @@
+import { TFilter } from '../../../components/surfboard/filter/types.js';
+import { DashboardInputScope, TDashboard } from '../../../lib/types/common-types.js';
+/**
+ * The reach conversion from a toolbar filter's own reach fields to a
+ * `DashboardInputScope` (one filter model SPEC 4.2), owned by the filter
+ * model. Since Phase 5 only the upgrade reads it: a stored filter has no
+ * reach fields, so nothing converts a scope back.
+ */
+/** The `TFilter` fields that store reach on the old shape. */
+export declare const TOOLBAR_FILTER_REACH_FIELDS: readonly ["sheetId", "applyToSheetIds", "excludeSheetIds", "applyToCardIds", "excludeCardIds"];
+export type ToolbarFilterReachField = (typeof TOOLBAR_FILTER_REACH_FIELDS)[number];
+/** Today's `doesFilterApplyToSheet`: does the toolbar filter reach this tab? */
+export declare function doesToolbarFilterReachTab(filter: TFilter, sheetId: string): boolean;
+/** Whether a toolbar filter stores any reach field. */
+export declare function hasToolbarFilterReachField(filter: TFilter): boolean;
+/** The filter without its reach fields (S-3). The same object when it has none. */
+export declare function withoutToolbarFilterReachFields(filter: TFilter): TFilter;
+/**
+ * Toolbar filter reach to scope (SPEC 4.2): the first matching row wins; for
+ * arrays "set" means `!== undefined`, for `sheetId` truthy; every id kept names
+ * an existing tab or card. Tab reach is the regular tabs the filter reaches.
+ */
+export declare function toolbarFilterScope(filter: TFilter, dashboard: Pick<TDashboard, 'sheets'>): DashboardInputScope;

package/dist/types/shared/dashboard-authoring/index.d.ts

@@ -16,6 +16,8 @@ export * from './dashboard-filter-automatic-target.js';
 export * from './dashboard-filter-sql-subscription.js';
 export * from './dashboard-filter-sql-target.js';
 export * from './dashboard-filter-mapping-contract.js';
+export * from './dashboard-input-scope.js';
+export * from './filter-model/index.js';
 export * from './dashboard-filter-value-compatibility.js';
 export * from './card-reference-remapping.js';
 export * from './apply-group-by-override.js';

package/dist/types/shared/format-utils/export-policy.d.ts

@@ -17,3 +17,15 @@ export declare const MATRIX_EXPORT_MAX_ENCODED_BYTES: number;
 export declare const MATRIX_EXPORT_MAX_ARTIFACT_BYTES: number;
 /** Return true when a complete CSV must use the asynchronous chunked path. */
 export declare function requiresChunkedCsvExport(totalRows: number): boolean;
+/** Where a data export (CSV or Excel) runs (background-activity BA-D2, SPEC §4.1). */
+export type DataExportRoute = 'direct' | 'background' | 'try-direct' | 'blocked';
+/**
+ * The one route rule for data exports in CSV and Excel (they share every
+ * limit): a Matrix tries the direct path first; a table routes on its loaded
+ * row count. The loaded count only routes; the server sizes the job (BA-D3).
+ */
+export declare function dataExportRoute(input: {
+    cardType: 'table' | 'detailTable' | 'matrixTable';
+    /** The loaded row count of a server-paged table, else null. */
+    loadedRowCount: number | null;
+}): DataExportRoute;

package/dist/types/shared/format-utils/exporters/index.d.ts

@@ -2,6 +2,8 @@ export { CSV_ENCODINGS, DEFAULT_CSV_ENCODING, CSV_DELIMITERS, CSV_RECORD_SEPARAT
 export type { CsvEncoding, CsvDelimiter, CsvCell } from './csv-utils.js';
 export { EXPORT_FILE_FORMATS, XLSX_CONTENT_TYPE, parseExportFileFormat, exportFileTraits, exportFileFormatFromStored, exportFileFormatFromContentType, exportFileName, } from './export-file-format.js';
 export type { ExportFileFormat, ExportFileTraits } from './export-file-format.js';
+export { EMAIL_IMAGE_DASHBOARD_WIDTH, IMAGE_CAPTURE_LIMITS, RENDERED_FILE_KINDS, cardImageSize, parseImageCaptureRequest, writeImageCaptureRequest, planImageViewport, renderedFileTraits, renderedFileName, sheetImageEntryName, } from './rendered-file.js';
+export type { ImageCaptureRequest, ImageViewport, ImageViewportPlan, RenderedFileKind, RenderedFileTraits, } from './rendered-file.js';
 export { resolveXlsxColumn, exportCellText } from './export-cells.js';
 export type { ExportDataType, XlsxColumnInput, XlsxColumnPresentation, XlsxColumn, ExportCell, ExportWallClock, } from './export-cells.js';
 export { XlsxLimitError, isXlsxLimitError, XLSX_LIMIT_FAILURE_REASONS, xlsxLimitFailureReason, assertXlsxColumnCount, defineXlsxSheet, serializeXlsxSheet, parseXlsxSheet, withXlsxSheetColumns, serializeXlsxColumns, parseXlsxColumns, xlsxColumnsFingerprint, encodeXlsxFile, encodeXlsxRows, streamXlsxFile, } from './xlsx-file.js';

package/dist/types/shared/format-utils/exporters/rendered-file.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The rendered file contract: what a file the renderer draws from the print
+ * view (a PDF or a PNG image, or a zip of sheet images) is called and typed
+ * as, and how big an image is. The browser, the app and the renderer (through
+ * its generated bundle) all read and write the image size through this module,
+ * so its limits and URL parameter names have one owner. See the PNG exports
+ * plan (semaphor-app docs/implementation-plans/png-exports, SPEC §2.1 to §2.3).
+ * IMPORTANT: No React or browser-specific imports allowed
+ */
+/** How big the image is. Every number is CSS pixels. */
+export type ImageCaptureRequest = 
+/** A downloaded card: its size on the viewer's screen, measured at the click. */
+{
+    fit: 'card';
+    cssWidth: number;
+    cssHeight: number;
+}
+/** An emailed card: the print page sizes it from its saved layout on a dashboard this wide (PN-D13). */
+ | {
+    fit: 'layout';
+    dashboardWidth: number;
+}
+/** A dashboard sheet: the width is the viewer's (or the reference width); the renderer measures the height. */
+ | {
+    fit: 'sheet';
+    cssWidth: number;
+};
+/** The dashboard width an emailed card or sheet is drawn at (PN-D13). */
+export declare const EMAIL_IMAGE_DASHBOARD_WIDTH = 1280;
+export declare const IMAGE_CAPTURE_LIMITS: {
+    readonly minCssWidth: 320;
+    readonly minCssHeight: 120;
+    readonly maxCardCssWidth: 4096;
+    readonly maxCardCssHeight: 4096;
+    readonly maxSheetCssWidth: 4096;
+    /** Chromium's largest capture in device pixels, either side. */
+    readonly maxDevicePixels: 16384;
+};
+type ParamSource = URLSearchParams | Readonly<Record<string, string | undefined>>;
+/** A card image's size, rounded and clamped to the card limits: the clamp the browser, the page and the renderer share. */
+export declare function cardImageSize(input: {
+    cssWidth: number;
+    cssHeight: number;
+}): {
+    cssWidth: number;
+    cssHeight: number;
+};
+/**
+ * Reads a request from URL parameters (`imageFit`, `imageWidth`, `imageHeight`;
+ * `imageWidth` is the dashboard width for `layout`)
+ * and clamps it. Null when a parameter is missing, not an integer, or does
+ * not match the fit. The browser, the app and the renderer read and write
+ * these parameters through this module only.
+ */
+export declare function parseImageCaptureRequest(params: ParamSource): ImageCaptureRequest | null;
+export declare function writeImageCaptureRequest(request: ImageCaptureRequest, params: URLSearchParams): void;
+export type ImageViewport = {
+    width: number;
+    height: number;
+    deviceScaleFactor: 1 | 2;
+};
+export type ImageViewportPlan = {
+    status: 'ready';
+    viewport: ImageViewport;
+}
+/** Even at scale 1 a side is over `maxDevicePixels`. */
+ | {
+    status: 'too_large';
+    cssWidth: number;
+    cssHeight: number;
+};
+/**
+ * The renderer's viewport. For `card`, the request's own size. For `layout`,
+ * the dashboard width by 1,024; the page sizes the card and the renderer
+ * captures the card's element. For `sheet`, `measuredCssHeight` is the
+ * sheet's full height after every card loaded; required for a sheet (throws
+ * without it), ignored otherwise.
+ */
+export declare function planImageViewport(request: ImageCaptureRequest, measuredCssHeight?: number): ImageViewportPlan;
+/** The kind of file a render produces. CSV keeps its own traits (`exportFileTraits`). */
+export type RenderedFileKind = 'pdf' | 'png' | 'zip';
+export type RenderedFileTraits = {
+    kind: RenderedFileKind;
+    extension: 'pdf' | 'png' | 'zip';
+    contentType: 'application/pdf' | 'image/png' | 'application/zip';
+    /** The customer's name for the format in dialogs and attachment lists. */
+    label: 'PDF' | 'PNG image' | 'PNG images (zip)';
+};
+export declare const RENDERED_FILE_KINDS: readonly ["pdf", "png", "zip"];
+export declare function renderedFileTraits(kind: RenderedFileKind): RenderedFileTraits;
+/**
+ * The saved file's name: `<title>-<ISO instant>.<extension>`, `Report` for an
+ * empty title. For kind `pdf` it equals today's inline name in
+ * `download-pdf.ts`. Used by the browser for every rendered file.
+ */
+export declare function renderedFileName(input: {
+    kind: RenderedFileKind;
+    title: string | null | undefined;
+    at: Date;
+}): string;
+/** One sheet's entry in an all-sheets zip: `01 Revenue.png`; position is 1-based, at least two digits; the title sanitized for a file name. */
+export declare function sheetImageEntryName(input: {
+    position: number;
+    title: string | null | undefined;
+}): string;
+export {};

package/package.json

@@ -5,7 +5,7 @@
     "email": "support@semaphor.cloud"
   },
   "license": "MIT",
-  "version": "0.1.543",
+  "version": "0.1.545",
   "description": "Fully interactive and customizable dashboards for your apps.",
   "keywords": [
     "react",
@@ -88,6 +88,10 @@
       "types": "./dist/types/brand-studio.d.ts",
       "import": "./dist/brand-studio/index.js"
     },
+    "./activity": {
+      "types": "./dist/types/activity.d.ts",
+      "import": "./dist/activity/index.js"
+    },
     "./briefings": {
       "types": "./dist/types/briefings.d.ts",
       "import": "./dist/briefings/index.js"
@@ -119,7 +123,7 @@
     "build": "node scripts/build.mjs",
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
     "lint:regressions": "node scripts/lint-regressions.mjs",
-    "check:guards": "node scripts/card-config-consumers.mjs && node scripts/components-entry-imports.mjs && node scripts/types-entry-imports.mjs && node scripts/card-query-assembly-imports.mjs && node scripts/assistant-chat-imports.mjs",
+    "check:guards": "node scripts/card-config-consumers.mjs && node scripts/components-entry-imports.mjs && node scripts/types-entry-imports.mjs && node scripts/card-query-assembly-imports.mjs && node scripts/assistant-chat-imports.mjs && node scripts/filter-model-reads.mjs",
     "preview": "vite preview",
     "test": "vitest run",
     "test:changed": "vitest run --changed",

package/dist/chunks/_commonjsHelpers-BkfeUUK-.js

@@ -1,28 +0,0 @@
-var u = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
-function f(e) {
-  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
-}
-function l(e) {
-  if (e.__esModule) return e;
-  var r = e.default;
-  if (typeof r == "function") {
-    var t = function o() {
-      return this instanceof o ? Reflect.construct(r, arguments, this.constructor) : r.apply(this, arguments);
-    };
-    t.prototype = r.prototype;
-  } else t = {};
-  return Object.defineProperty(t, "__esModule", { value: !0 }), Object.keys(e).forEach(function(o) {
-    var n = Object.getOwnPropertyDescriptor(e, o);
-    Object.defineProperty(t, o, n.get ? n : {
-      enumerable: !0,
-      get: function() {
-        return e[o];
-      }
-    });
-  }), t;
-}
-export {
-  l as a,
-  u as c,
-  f as g
-};