@adminiumjs/i18n 0.3.16 → 0.3.18-rc.0

package/dist/resources/en-us/common-deferred.d.ts

@@ -0,0 +1,546 @@
+/**
+ * GENERATED MIRROR of ../../../locales/en-US/common.json (its builder, kb, about, team groups: en-US's deferred part of `common`) — do not edit by hand.
+ * The JSON file is the canonical hand-authored bundle;
+ * this TS mirror exists so the runtime can bundle a namespace (en-US's eager
+ * ones) or chunk-split it (every other locale, and en-US's deferred `studio`)
+ * without JSON import attributes (browser + NodeNext safe).
+ * Parity is enforced by src/resources/parity.test.ts. Regenerate with
+ * scripts/gen-resources.mjs.
+ */
+declare const _default: {
+    readonly builder: {
+        readonly view: "View";
+        readonly edit: "Edit";
+        readonly done: "Done";
+        readonly addWidget: "Add widget";
+        readonly saveLayout: "Save layout";
+        readonly saving: "Saving…";
+        readonly savedShort: "Saved";
+        readonly options: "Dashboard options";
+        readonly resetLayout: "Reset layout";
+        readonly resetTitle: "Reset to the shared layout?";
+        readonly resetBody: "This removes your personal changes and restores the dashboard everyone sees. Your data isn’t affected.";
+        readonly resetConfirm: "Reset layout";
+        readonly resetDone: "Layout reset to the shared default.";
+        readonly sharedNote: "You’re editing the shared dashboard everyone sees.";
+        readonly personalNote: "You’re editing your personal layout — only you see these changes.";
+        readonly savedShared: "Dashboard saved for everyone with access.";
+        readonly empty: "This dashboard has no widgets yet.";
+        readonly emptyAction: "Add a widget";
+        readonly palette: {
+            readonly title: "Add a widget";
+            readonly count: "{count} widgets";
+            readonly searchLabel: "Search widgets";
+            readonly searchPlaceholder: "Search widgets…";
+            readonly clear: "Clear search";
+            readonly noResults: "No widgets match “{query}”.";
+            readonly add: "Add {name}";
+            readonly added: "{name} added.";
+        };
+        readonly inspector: {
+            readonly title: "Configure widget";
+            readonly empty: "This widget has no options to configure.";
+            readonly locked: "Locked";
+            readonly lockedHint: "This field is set by the source and can’t be edited here.";
+            readonly selectPlaceholder: "Select…";
+            readonly increment: "Increase";
+            readonly decrement: "Decrease";
+            readonly done: "Done";
+        };
+        readonly item: {
+            readonly configure: "Configure {name}";
+            readonly duplicate: "Duplicate {name}";
+            readonly remove: "Remove {name}";
+            readonly removed: "{name} removed.";
+            readonly duplicated: "{name} duplicated.";
+            readonly unboundHint: "This widget shows sample data here and on the live page. Open Configure to connect it to a table.";
+            readonly unbound: "Sample data";
+        };
+        readonly families: {
+            readonly kpi: "KPIs";
+            readonly charts: "Charts";
+            readonly tables: "Tables";
+            readonly feeds: "Feeds";
+            readonly calendar: "Calendar";
+            readonly boards: "Boards";
+            readonly geo: "Maps";
+            readonly media: "Media";
+            readonly communication: "Communication";
+            readonly forms: "Forms";
+            readonly chrome: "Navigation";
+            readonly system: "System";
+            readonly domain: "Domain";
+        };
+        readonly versions: "Versions";
+        readonly versionsEmpty: "No saved versions yet";
+        readonly saveAsVersion: "Save as version";
+        readonly saveVersionTitle: "Save a version";
+        readonly saveVersionBody: "Snapshots the current document. Restore it any time from Versions.";
+        readonly versionName: "Version name";
+        readonly versionNamePlaceholder: "e.g. Before Q3 rates change";
+        readonly discard: "Discard changes";
+        readonly discardTitle: "Discard your changes?";
+        readonly discardBody: "The dashboard goes back to how it looked when you opened the editor. Your data isn’t affected.";
+        readonly discardConfirm: "Discard changes";
+        readonly keepEditing: "Keep editing";
+        readonly discarded: "Changes discarded.";
+        readonly binding: {
+            readonly addFilter: "Add filter";
+            readonly brokenBody: "It no longer matches a query this version understands, so the widget shows an error on the live page.";
+            readonly brokenTitle: "This widget’s query is broken";
+            readonly bucketColumn: "Date column";
+            readonly bucketRequired: "Pick the column that carries the date.";
+            readonly bucketUnit: "Group time by";
+            readonly columnNone: "None";
+            readonly columnPlaceholder: "Choose a column…";
+            readonly connect: "Connect to data";
+            readonly edit: "Edit query";
+            readonly event: {
+                readonly category: "Category column (optional)";
+                readonly date: "Start date column";
+                readonly end: "End date column (optional)";
+                readonly title: "Title column";
+            };
+            readonly filterColumnRequired: "Pick a column.";
+            readonly filterColumn: "Column";
+            readonly filterListHelper: "Separate values with commas.";
+            readonly filterOp: "Condition";
+            readonly filterValue: "Value";
+            readonly fn: {
+                readonly avg: "Average";
+                readonly countDistinct: "Count of distinct values";
+                readonly count: "Count of rows";
+                readonly max: "Maximum";
+                readonly min: "Minimum";
+                readonly sum: "Sum";
+            };
+            readonly groupByColumns: "Columns";
+            readonly groupByRequired: "This view needs a breakdown column.";
+            readonly groupByRows: "Rows";
+            readonly groupBy: "Group by";
+            readonly incompleteBody: "Fill in the highlighted fields — a half-written query would fail on the live dashboard.";
+            readonly incompleteTitle: "This query isn’t finished";
+            readonly limit: "Most rows to fetch";
+            readonly loadingSchema: "Loading tables…";
+            readonly lossyBody: "Parts of it — extra measures, sorts or page-filter links — aren’t shown here and will be dropped if you save.";
+            readonly lossyTitle: "This query is more advanced than the editor";
+            readonly measureColumnRequired: "This calculation needs a column.";
+            readonly measureColumn: "Of column";
+            readonly measureFn: "Calculate";
+            readonly noConnectionBody: "Widgets can only be bound on a page that belongs to a connection.";
+            readonly noConnectionTitle: "This page has no database connection";
+            readonly noDateColumns: "This table has no date or timestamp column.";
+            readonly noFilters: "No filters — every row in the table is counted.";
+            readonly noSnapshotBody: "Tables and columns come from the connection’s last introspection. Run introspection in Studio, then reopen this editor.";
+            readonly noSnapshotTitle: "No schema snapshot for this connection";
+            readonly op: {
+                readonly between: "is between";
+                readonly ilike: "contains (any case)";
+                readonly in: "is one of";
+                readonly isNull: "is empty";
+                readonly like: "contains";
+                readonly notNull: "is not empty";
+            };
+            readonly orderAsc: "Oldest / lowest first";
+            readonly orderBy: "Sort by";
+            readonly orderDesc: "Newest / highest first";
+            readonly orderDir: "Direction";
+            readonly orderNone: "Database order";
+            readonly pickTableFirst: "Pick a table to choose its columns.";
+            readonly removeFilter: "Remove filter";
+            readonly remove: "Remove data source";
+            readonly save: "Use this query";
+            readonly sectionBreakdown: "Breakdown";
+            readonly sectionColumns: "Columns";
+            readonly sectionFilters: "Filters";
+            readonly sectionMeasure: "Measure";
+            readonly sectionRows: "Rows";
+            readonly sectionSource: "Source";
+            readonly sectionTime: "Time axis";
+            readonly sectionWindow: "Period";
+            readonly selectColumns: "Columns to show";
+            readonly selectRequired: "Choose at least one column to show.";
+            readonly shape: {
+                readonly calendarEvents: "Dated events";
+                readonly categorical: "A value per category";
+                readonly distribution: "The spread of one column";
+                readonly matrix: "A grid of rows by columns";
+                readonly metricDelta: "A number, compared to the period before";
+                readonly multiTimeseries: "One line over time per category";
+                readonly recordList: "A list of rows";
+                readonly record: "One row";
+                readonly singleMetric: "A single number";
+                readonly stream: "A live feed of recent rows";
+                readonly timeseries: "A value over time";
+                readonly tree: "A value per category, split in two levels";
+                readonly geoPoints: "A value per place or region";
+                readonly flows: "How much moves from one category to another";
+                readonly ohlc: "Open, high, low and close per period";
+                readonly booleanMap: "An on/off flag per key";
+            };
+            readonly shapeHelper: "Changing this changes which query controls apply.";
+            readonly shapeLabel: "What this widget shows";
+            readonly summaryColumns: "{count, plural, one {# column} other {# columns}}";
+            readonly summaryFilters: "{count, plural, one {# filter} other {# filters}}";
+            readonly tableEmpty: "No matching table.";
+            readonly tablePlaceholder: "Search tables…";
+            readonly tableRequired: "Pick a table to query.";
+            readonly table: "Table or view";
+            readonly title: "Data source";
+            readonly unbindableBody: "It shows the shape of data the query engine doesn’t build yet, so it renders its own sample content.";
+            readonly unbindableTitle: "This widget can’t query data yet";
+            readonly unboundBody: "It shows sample numbers here AND on the live page. Connect it to a table to show real data.";
+            readonly unboundTitle: "Not connected to your data";
+            readonly unit: {
+                readonly day: "Daily";
+                readonly hour: "Hourly";
+                readonly month: "Monthly";
+                readonly quarter: "Quarterly";
+                readonly week: "Weekly";
+                readonly year: "Yearly";
+            };
+            readonly valueColumnRequired: "Pick the column to measure.";
+            readonly valueColumn: "Value column";
+            readonly windowColumn: "Date column";
+            readonly windowLast: "Last";
+            readonly windowNone: "All time";
+            readonly windowRequired: "Comparing to the previous period needs a date column.";
+            readonly windowUnit: {
+                readonly day: "days";
+                readonly hour: "hours";
+                readonly month: "months";
+                readonly quarter: "quarters";
+                readonly week: "weeks";
+                readonly year: "years";
+            };
+            readonly windowUnitLabel: "Unit";
+            readonly role: {
+                readonly flagKey: "Key column";
+                readonly flagValue: "On/off column";
+            };
+            readonly roleColumnsRequired: "Fill every required column, and leave no gaps before one you filled — these columns are read in order.";
+        };
+    };
+    readonly kb: {
+        readonly title: "Knowledge Base";
+        readonly subtitle: "{count, plural, one {# guide} other {# guides}} · full docs at docs.adminium.dev";
+        readonly openDocs: "Open the docs";
+        readonly browse: "Browse by topic";
+        readonly hero: {
+            readonly title: "How can we help?";
+            readonly subtitle: "Search guides, API docs and troubleshooting.";
+            readonly placeholder: "Search the knowledge base…";
+            readonly label: "Search the knowledge base";
+            readonly clear: "Clear search";
+        };
+        readonly category: {
+            readonly start: "Getting started";
+            readonly connect: "Connecting data";
+            readonly api: "API & developers";
+            readonly security: "Security & access";
+            readonly selfhost: "Self-hosting";
+            readonly trouble: "Troubleshooting";
+            readonly count: "{count, plural, one {# article} other {# articles}}";
+            readonly selected: "Filtering";
+        };
+        readonly list: {
+            readonly all: "All guides";
+            readonly clear: "Clear filter";
+        };
+        readonly empty: {
+            readonly title: "No guides match your search";
+            readonly body: "Try a different word, or search the full documentation at docs.adminium.dev.";
+            readonly openDocs: "Open the docs";
+        };
+        readonly article: {
+            readonly apiKeys: {
+                readonly title: "Authenticating with API keys";
+                readonly excerpt: "Create and revoke keys, and why a key is only ever shown to you once.";
+            };
+            readonly audit: {
+                readonly title: "Reading the audit log";
+                readonly excerpt: "Who changed what, when, and from where.";
+            };
+            readonly backup: {
+                readonly title: "Back up and move an instance";
+                readonly excerpt: "export-zip bundles your server config; import it to replay the same setup elsewhere.";
+            };
+            readonly columnRules: {
+                readonly title: "Rules on a column";
+                readonly excerpt: "What fills a column, what it accepts and what its limits are — on every write, not just one form.";
+            };
+            readonly connectDb: {
+                readonly title: "Connecting your first database";
+                readonly excerpt: "Point Adminium at PostgreSQL, MySQL or SQLite and generate an admin app.";
+            };
+            readonly connectionFails: {
+                readonly title: "A database connection fails";
+                readonly excerpt: "Read the diagnostics card: host, port, TLS, and the IP your database must allow.";
+            };
+            readonly createDialog: {
+                readonly title: "The New and Edit dialogs";
+                readonly excerpt: "Where every field comes from, and how to design your own instead of the generated one.";
+            };
+            readonly docker: {
+                readonly title: "Self-host with Docker";
+                readonly excerpt: "The official image, docker-compose, and running a separate meta database.";
+            };
+            readonly firstAdmin: {
+                readonly title: "Create your first super admin";
+                readonly excerpt: "What the first-run wizard asks for, and why it can only run once.";
+            };
+            readonly install: {
+                readonly title: "Install Adminium";
+                readonly excerpt: "Create a project with one command, or run Adminium from Docker or a source checkout.";
+            };
+            readonly lineItems: {
+                readonly title: "Line items and bookings";
+                readonly excerpt: "Tables of child rows with live totals, calendars bound to what is already booked, and one record per chip.";
+            };
+            readonly manifest: {
+                readonly title: "The page manifest";
+                readonly excerpt: "How a page is described as config, and how to hand-edit one.";
+            };
+            readonly missingTables: {
+                readonly title: "Tables are missing after introspection";
+                readonly excerpt: "Schema visibility, excluded tables, and re-running generation.";
+            };
+            readonly readOnly: {
+                readonly title: "Use a read-only role";
+                readonly excerpt: "Introspection reads schema metadata only. Give Adminium the least privilege it needs.";
+            };
+            readonly rest: {
+                readonly title: "REST API reference";
+                readonly excerpt: "Every endpoint the generated app exposes, with request and response shapes.";
+            };
+            readonly publicApi: {
+                readonly title: "Endpoints and keys for your pages";
+                readonly excerpt: "Let a page or another server call the tables you choose, with keys scoped to endpoints and methods.";
+            };
+            readonly apiDocsPage: {
+                readonly title: "The API documentation page";
+                readonly excerpt: "Publish /api-docs so the people who call your API can browse it and try a request.";
+            };
+            readonly roles: {
+                readonly title: "Roles & permissions";
+                readonly excerpt: "Assign Viewer, Editor and Admin, and build your own roles from the permission matrix.";
+            };
+            readonly schemaFile: {
+                readonly title: "Generate from a schema file";
+                readonly excerpt: "Upload a Prisma schema, a Django models.py, a Rails schema.rb or a .sql dump — no connection needed.";
+            };
+            readonly secrets: {
+                readonly title: "How Adminium stores your secrets";
+                readonly excerpt: "Connection credentials are encrypted at rest with ADMINIUM_SECRET. API keys are hashed.";
+            };
+            readonly tableFilters: {
+                readonly title: "Filtering a table";
+                readonly excerpt: "The six kinds of filter, the two a page gets on its own, and how they ride into a saved view.";
+            };
+            readonly telemetry: {
+                readonly title: "Telemetry and update checks";
+                readonly excerpt: "Both are opt-in and off by default. What is sent if you turn them on.";
+            };
+        };
+    };
+    readonly about: {
+        readonly title: "About Adminium";
+        readonly subtitle: "Version, licence, and where this instance’s source code lives.";
+        readonly version: "Version";
+        readonly license: "Licence";
+        readonly metaStore: "Meta store";
+        readonly node: "Node.js";
+        readonly engine: {
+            readonly postgres: "PostgreSQL";
+            readonly mysql: "MySQL / MariaDB";
+            readonly sqlite: "SQLite";
+        };
+        readonly licenseCard: {
+            readonly title: "Free and open source";
+            readonly body: "Adminium is licensed under the GNU Affero General Public License v3.0. You are free to run, study, modify, and share it. If you offer a modified version to others over a network, the AGPL asks you to offer them its source code too.";
+        };
+        readonly viewLicense: "Read the licence";
+        readonly viewSource: "Get the source code";
+        readonly updates: {
+            readonly title: "Updates";
+            readonly description: "Whether this instance checks for new releases.";
+        };
+        readonly update: {
+            readonly disabled: "Update checks are off, so this instance never contacts GitHub. Turn them on in Settings to hear about new releases.";
+            readonly current: "You are on the latest release.";
+            readonly available: "Adminium {version} is available";
+            readonly availableBody: "You are running {version}.";
+            readonly viewRelease: "View release notes";
+        };
+        readonly desktop: {
+            readonly unknown: "Unknown";
+            readonly appVersion: "App version";
+            readonly serverVersion: "Server version";
+            readonly migration: "Meta-store migration";
+            readonly electron: "Electron";
+            readonly chromium: "Chromium";
+            readonly runtimeNode: "Node runtime";
+            readonly system: {
+                readonly title: "System";
+            };
+            readonly dataDir: "Data directory";
+            readonly reveal: "Show in folder";
+            readonly secret: {
+                readonly title: "Secret storage";
+                readonly safe: "Encrypted by your operating system";
+                readonly plainWarning: "This computer has no system keychain available, so your Adminium secret is stored unencrypted on disk. Anyone who can read this machine’s files can read it. Set up a login keychain (or a Linux secret service) and restart Adminium to protect it.";
+            };
+            readonly updates: {
+                readonly title: "Updates";
+                readonly mode: {
+                    readonly notify: "Notify me about new versions";
+                    readonly manual: "Only when I check";
+                    readonly disabled: "Off (air-gapped)";
+                };
+                readonly disabledBody: "Automatic updates are off (air-gapped). Install new versions manually.";
+                readonly check: "Check for updates";
+                readonly checking: "Checking…";
+                readonly lastChecked: "Last checked {when}";
+                readonly available: "Version {version} is available";
+                readonly none: "You are on the latest version.";
+                readonly unavailable: "Updates are turned off in this installation.";
+                readonly error: "Could not check for updates.";
+                readonly download: "Download update";
+                readonly downloading: "Downloading… {percent}%";
+                readonly downloaded: "Version {version} is ready to install";
+                readonly restart: "Restart to install";
+                readonly downloadError: "The download did not finish. You can try again.";
+                readonly toast: {
+                    readonly available: "A new version of Adminium is available";
+                    readonly view: "View";
+                    readonly downloaded: "Update ready to install";
+                    readonly restart: "Restart now";
+                };
+            };
+            readonly legal: {
+                readonly title: "Licences";
+                readonly agpl: "Adminium Desktop is free software under the GNU Affero General Public License v3.0.";
+                readonly viewLicense: "View licence";
+                readonly licenseTitle: "GNU Affero General Public License v3.0";
+                readonly licenseUnavailable: "The bundled licence file is not available in this build.";
+                readonly viewNotices: "Third-party licences";
+                readonly noticesTitle: "Third-party notices";
+                readonly noticesUnavailable: "Third-party notices are generated when the app is packaged and are not available in this build.";
+                readonly source: "Source code";
+                readonly close: "Close";
+            };
+            readonly telemetry: {
+                readonly title: "Anonymous usage data";
+                readonly label: "Share anonymous usage data";
+                readonly description: "Helps us decide which database engines to prioritise. Off unless you turn it on; no schema, data, or personal information is ever sent.";
+                readonly saveFailed: "Could not save that setting. Try again.";
+            };
+            readonly diagnostics: {
+                readonly title: "Diagnostics";
+                readonly description: "Details that help when you report a problem. No schema or data is included.";
+                readonly copy: "Copy diagnostic info";
+                readonly copied: "Copied";
+                readonly showLogs: "Show logs";
+                readonly dataSize: "Data size: {size}";
+            };
+        };
+    };
+    readonly team: {
+        readonly action: {
+            readonly reactivate: "Reactivate";
+            readonly remove: "Delete";
+            readonly resend: "New link";
+            readonly roles: "Roles";
+            readonly suspend: "Suspend";
+        };
+        readonly column: {
+            readonly actions: "Actions";
+            readonly lastSeen: "Last seen";
+            readonly person: "Person";
+            readonly roles: "Roles";
+            readonly status: "Status";
+        };
+        readonly counts: "{active} active · {invited} invited · {suspended} suspended";
+        readonly empty: {
+            readonly body: "Invite a teammate to give them their own sign-in and role.";
+            readonly filtered: {
+                readonly body: "Clear the filters to see the whole directory.";
+                readonly title: "No one matches these filters";
+            };
+            readonly title: "Only you have an account";
+        };
+        readonly filterRoleAny: "Any role";
+        readonly filterRole: "Filter by role";
+        readonly filterStatusAny: "Any status";
+        readonly filterStatus: "Filter by status";
+        readonly invite: {
+            readonly copied: "Copied";
+            readonly copyLink: "Copy link";
+            readonly created: {
+                readonly body: "Send this link to {email} yourself. It is shown once — Adminium stores only a hash of it, so if you lose it you will have to delete the invitation and issue a new one.";
+                readonly title: "Invitation created";
+                readonly bodyEmailed: "Adminium emailed this link to {email}. It is here too in case the email does not arrive, and it is shown once — Adminium stores only a hash of it.";
+            };
+            readonly emailIt: "Email the invitation";
+            readonly expiresRelative: "The link expires {at} ({relative}).";
+            readonly expires: "The link expires {at}.";
+            readonly noEmail: {
+                readonly smtp: "No SMTP server is configured on this instance, so there is nothing to send mail with. Share the link over a channel you already trust.";
+                readonly title: "Adminium did not email this link";
+                readonly unknown: "Adminium could not check whether this instance can send mail. Share the link over a channel you already trust.";
+            };
+            readonly emailed: {
+                readonly title: "Adminium emailed this link";
+                readonly body: "The invitation is on its way to {email}. If it has not arrived in a few minutes, share the link above over a channel you already trust.";
+            };
+        };
+        readonly inviteButton: "Invite teammate";
+        readonly inviteDialog: {
+            readonly description: "Adminium creates the account and gives you a one-time activation link to pass on.";
+            readonly emailPlaceholder: "name@example.com";
+            readonly email: "Email";
+            readonly failed: "Could not create the invitation";
+            readonly namePlaceholder: "e.g. Dana Osei";
+            readonly name: "Name";
+            readonly rolesHelper: "Pick the least-privileged role that lets them do their job. You can change this later.";
+            readonly roles: "Roles";
+            readonly submit: "Create invitation";
+            readonly title: "Invite a teammate";
+        };
+        readonly listFailed: {
+            readonly title: "Could not load the directory";
+        };
+        readonly loadMore: "Load more";
+        readonly neverSignedIn: "Never signed in";
+        readonly noRoles: "No roles";
+        readonly remove: {
+            readonly body: "This erases {name}’s account, their preferences and their sign-in sessions, and blanks their name from the record of settings they changed. Suspending instead keeps all of it and only stops them signing in. This cannot be undone.";
+            readonly confirm: "Delete permanently";
+            readonly prompt: "Type “{email}” to confirm";
+            readonly title: "Delete account permanently";
+            readonly failed: "The account was not deleted";
+        };
+        readonly roles: {
+            readonly unavailable: "Roles are not visible to your account, so none can be assigned here.";
+        };
+        readonly rolesDialog: {
+            readonly description: "A user gets the union of every role they hold.";
+            readonly failed: "Could not change the roles";
+            readonly title: "Roles for {name}";
+        };
+        readonly rolesLocked: "Changing roles needs the “Manage roles” permission.";
+        readonly search: "Search name or email";
+        readonly status: {
+            readonly active: "Active";
+            readonly invited: "Invited";
+            readonly suspended: "Suspended";
+        };
+        readonly subtitle: "Who has an account on this Adminium, and what each of them can do.";
+        readonly title: "Team";
+        readonly twoFactorOn: "Two-factor authentication is on";
+        readonly twoFactorShort: "2FA";
+        readonly actionFailed: "That change was not made";
+    };
+};
+export default _default;
+//# sourceMappingURL=common-deferred.d.ts.map

package/dist/resources/en-us/common-deferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-deferred.d.ts","sourceRoot":"","sources":["../../../src/resources/en-us/common-deferred.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBAshBW"}