@mulmoclaude/accounting-plugin 1.0.0 → 1.0.1

package/dist/shared-CcU3_qAa.cjs

@@ -0,0 +1,749 @@
+//#region src/shared/actions.ts
+var ACCOUNTING_ACTIONS = {
+	openBook: "openBook",
+	getBooks: "getBooks",
+	createBook: "createBook",
+	updateBook: "updateBook",
+	deleteBook: "deleteBook",
+	getAccounts: "getAccounts",
+	upsertAccount: "upsertAccount",
+	addEntries: "addEntries",
+	voidEntry: "voidEntry",
+	getJournalEntries: "getJournalEntries",
+	getOpeningBalances: "getOpeningBalances",
+	setOpeningBalances: "setOpeningBalances",
+	getReport: "getReport",
+	getTimeSeries: "getTimeSeries",
+	rebuildSnapshots: "rebuildSnapshots"
+};
+//#endregion
+//#region src/shared/api.ts
+var ACCOUNTING_API = { dispatch: {
+	path: "/api/accounting",
+	method: "POST"
+} };
+//#endregion
+//#region src/shared/types.ts
+var ACCOUNT_TYPES = [
+	"asset",
+	"liability",
+	"equity",
+	"income",
+	"expense"
+];
+/** B/S accounts (assets / liabilities / equity). Used by opening
+*  balance validation: opening entries reference balance-sheet
+*  accounts only. */
+var BALANCE_SHEET_ACCOUNT_TYPES = [
+	"asset",
+	"liability",
+	"equity"
+];
+//#endregion
+//#region src/shared/channels.ts
+/** Channel factory for per-book event streams. Subscribers:
+*  `useAccountingChannel(bookId)`. Publisher: the package's server
+*  surface `eventPublisher`. */
+function bookChannel(bookId) {
+	return `accounting:${bookId}`;
+}
+/** Book-list-level channel — a book was created / deleted. Subscribers
+*  refetch the BookSwitcher dropdown. Mirrors the host META's
+*  `staticChannels.accountingBooks` literal (kept in sync by value;
+*  the host META stays the codegen-discoverable source for the
+*  aggregator merge). */
+var ACCOUNTING_BOOKS_CHANNEL = "accounting:books";
+/** Event kinds that ride `bookChannel(bookId)`. Single source of
+*  truth for both publishers (server/accounting) and subscribers
+*  (the View) — anyone branching on event kind imports from here
+*  and the type system catches drift on either side.
+*
+*  - `journal`             — addEntry / voidEntry hit the books at `period`.
+*                            Refetch the journal list and (if the View is
+*                            showing balances at or after `period`) the
+*                            relevant report.
+*  - `opening`             — setOpeningBalances. Affects every period from
+*                            the opening date forward; refetch everything.
+*  - `accounts`            — chart-of-accounts mutation that may affect
+*                            aggregation (account type changed). Refetch
+*                            accounts and the active report.
+*  - `snapshotsRebuilding` / `snapshotsReady` — purely informational;
+*                            the View can show a "calculating" spinner
+*                            during rebuild, but the lazy-rebuild safety
+*                            net means a refetch always returns the right
+*                            answer regardless. */
+var BOOK_EVENT_KINDS = {
+	journal: "journal",
+	opening: "opening",
+	accounts: "accounts",
+	snapshotsRebuilding: "snapshots-rebuilding",
+	snapshotsReady: "snapshots-ready"
+};
+//#endregion
+//#region ../../common/dist/index.js
+/** Narrow `unknown` to a plain object (not null, not array). */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Check that a record has a specific key with a string value. */
+function hasStringProp(value, key) {
+	return isRecord(value) && typeof value[key] === "string";
+}
+/** Normalise an unknown thrown value into a human-readable string. Isomorphic
+*  (host, bridges, plugins, Vue) — this is the single home for the helper that
+*  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`
+*  is server-only.
+*
+*  A non-Error object with a non-empty string `details` (gRPC convention) or
+*  `message` field surfaces that field — `details` wins — instead of the
+*  `[object Object]` a bare `String(err)` would print; an empty-string field
+*  falls through. `fallback` covers the error-boundary idiom where a thrown
+*  non-Error should read as a descriptive message rather than `String(err)`
+*  noise; omit it in logging contexts where `String(err)` is fine. */
+function errorMessage(err, fallback) {
+	if (err instanceof Error) return err.message;
+	if (hasStringProp(err, "details") && err.details) return err.details;
+	if (hasStringProp(err, "message") && err.message) return err.message;
+	if (fallback !== void 0) return fallback;
+	return String(err);
+}
+//#endregion
+//#region src/shared/paths.ts
+var ACCOUNTING_DIRS = {
+	/** `data/accounting/config.json` + the books tree below. */
+	accounting: "data/accounting",
+	/** `data/accounting/books/<bookId>/{accounts.json, journal/, snapshots/}`. */
+	accountingBooks: "data/accounting/books"
+};
+//#endregion
+//#region src/shared/fiscalYear.ts
+var FISCAL_YEAR_END_MONTHS = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12
+];
+var DEFAULT_FISCAL_YEAR_END = 12;
+/** Legacy calendar-quarter tokens → closing month, for books written
+*  before the field became a month number. */
+var LEGACY_QUARTER_MONTHS = {
+	Q1: 3,
+	Q2: 6,
+	Q3: 9,
+	Q4: 12
+};
+function isFiscalYearEnd(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 12;
+}
+/** Normalise any stored / inbound value to a concrete closing month.
+*  Absent or unrecognised → the default (December); a legacy "Q1".."Q4"
+*  token → its closing month; a valid 1-12 number → itself. Kept
+*  tolerant (unknown input) so a legacy book read from disk — or shared
+*  with an older MulmoTerminal — never breaks the UI or a report. */
+function resolveFiscalYearEnd(value) {
+	if (isFiscalYearEnd(value)) return value;
+	if (typeof value === "string" && Object.hasOwn(LEGACY_QUARTER_MONTHS, value)) return LEGACY_QUARTER_MONTHS[value];
+	return 12;
+}
+/** Last calendar month (1-12) of the fiscal year. The stored token IS
+*  the closing month now, so this reads as `resolveFiscalYearEnd` under
+*  a name that states intent at the call sites (and still absorbs a
+*  stray legacy token defensively). */
+function fiscalYearEndMonth(end) {
+	return resolveFiscalYearEnd(end);
+}
+/** Localised label for a fiscal-year-end month, showing that month's
+*  last day — e.g. 8 → "August 31" / "8月31日" / "31 de agosto". Uses a
+*  fixed non-leap reference year, so February reads as the 28th; this
+*  is display only — the engine still computes the real last day
+*  (Feb 29 in a leap year) at runtime. */
+function fiscalYearEndMonthLabel(month, locale) {
+	const lastDay = new Date(Date.UTC(2001, month, 0));
+	try {
+		return new Intl.DateTimeFormat(locale, {
+			month: "long",
+			day: "numeric",
+			timeZone: "UTC"
+		}).format(lastDay);
+	} catch {
+		return String(month);
+	}
+}
+function pad2$1(num) {
+	return String(num).padStart(2, "0");
+}
+function lastDayOfMonth(year, monthZeroBased) {
+	return new Date(year, monthZeroBased + 1, 0).getDate();
+}
+function ymd(year, monthOneBased, day) {
+	return `${year}-${pad2$1(monthOneBased)}-${pad2$1(day)}`;
+}
+/** Fiscal quarter index (0..3) of the given local date under `end`,
+*  where 0 is the first quarter of the fiscal year (right after the
+*  prior year's close) and 3 is the closing quarter. */
+function fiscalQuarterIndex(end, today) {
+	const closingMonth = fiscalYearEndMonth(end);
+	const offset = (today.getMonth() + 1 - closingMonth - 1 + 12) % 12;
+	return Math.floor(offset / 3);
+}
+/** Calendar (year, monthOneBased) of the *first* month of the fiscal
+*  quarter at index `index` in the fiscal year that *contains*
+*  `today`. Returned both as the first day of that month and as the
+*  count of months covered (always 3 — exposed as a constant). */
+function fiscalQuarterStart(end, today, index) {
+	const closingMonth = fiscalYearEndMonth(end);
+	const todayMonth = today.getMonth() + 1;
+	const todayYear = today.getFullYear();
+	const startMonth = closingMonth % 12 + 1;
+	const fyStartYear = todayMonth >= startMonth ? todayYear : todayYear - 1;
+	const flatMonth = startMonth + index * 3;
+	return {
+		year: fyStartYear + Math.floor((flatMonth - 1) / 12),
+		month: (flatMonth - 1) % 12 + 1
+	};
+}
+function quarterRangeAt(end, today, index) {
+	const start = fiscalQuarterStart(end, today, index);
+	const lastMonthFlat = start.month - 1 + 2;
+	const lastMonthYear = start.year + Math.floor(lastMonthFlat / 12);
+	const lastMonth = lastMonthFlat % 12 + 1;
+	const lastDay = lastDayOfMonth(lastMonthYear, lastMonth - 1);
+	return {
+		from: ymd(start.year, start.month, 1),
+		to: ymd(lastMonthYear, lastMonth, lastDay)
+	};
+}
+function currentQuarterRange(end, today = /* @__PURE__ */ new Date()) {
+	return quarterRangeAt(end, today, fiscalQuarterIndex(end, today));
+}
+function previousQuarterRange(end, today = /* @__PURE__ */ new Date()) {
+	const idx = fiscalQuarterIndex(end, today);
+	if (idx > 0) return quarterRangeAt(end, today, idx - 1);
+	return quarterRangeAt(end, new Date(today.getFullYear(), today.getMonth() - 3, 1), 3);
+}
+/** Current fiscal year — Q0 start through Q3 close. */
+function currentFiscalYearRange(end, today = /* @__PURE__ */ new Date()) {
+	const first = quarterRangeAt(end, today, 0);
+	const last = quarterRangeAt(end, today, 3);
+	return {
+		from: first.from,
+		to: last.to
+	};
+}
+function previousFiscalYearRange(end, today = /* @__PURE__ */ new Date()) {
+	return currentFiscalYearRange(end, new Date(today.getFullYear() - 1, today.getMonth(), today.getDate()));
+}
+//#endregion
+//#region src/shared/countries.ts
+/** ISO 3166-1 alpha-2 country codes shown in the book country
+*  dropdown. Curated to cover every jurisdiction the Accounting role
+*  has explicit tax-registration advice for, plus the major economies
+*  represented in `SUPPORTED_CURRENCY_CODES`. */
+var SUPPORTED_COUNTRY_CODES = [
+	"US",
+	"JP",
+	"GB",
+	"CA",
+	"AU",
+	"NZ",
+	"DE",
+	"FR",
+	"IT",
+	"ES",
+	"NL",
+	"BE",
+	"AT",
+	"IE",
+	"PT",
+	"FI",
+	"SE",
+	"DK",
+	"PL",
+	"CH",
+	"NO",
+	"CN",
+	"KR",
+	"TW",
+	"HK",
+	"SG",
+	"IN",
+	"BR",
+	"MX"
+];
+/** EU member states as of 2026. Used by the role-prompt advice path
+*  to recommend a VAT identification number when the book country is
+*  in the EU. */
+var EU_COUNTRY_CODES = /* @__PURE__ */ new Set([
+	"AT",
+	"BE",
+	"BG",
+	"CY",
+	"CZ",
+	"DE",
+	"DK",
+	"EE",
+	"ES",
+	"FI",
+	"FR",
+	"GR",
+	"HR",
+	"HU",
+	"IE",
+	"IT",
+	"LT",
+	"LU",
+	"LV",
+	"MT",
+	"NL",
+	"PL",
+	"PT",
+	"RO",
+	"SE",
+	"SI",
+	"SK"
+]);
+/** Localized human name for a country code. Falls back to the code
+*  itself if the runtime can't resolve the name. */
+function localizedCountryName(code, locale) {
+	try {
+		return new Intl.DisplayNames([locale], { type: "region" }).of(code) ?? code;
+	} catch {
+		return code;
+	}
+}
+/** Runtime guard for `BookSummary.country`. The type is the union
+*  `SupportedCountryCode`, but every entry point that takes user /
+*  LLM input arrives as raw `string` (form submit, JSON-RPC body),
+*  so the service layer narrows here before persisting. */
+function isSupportedCountryCode(value) {
+	return typeof value === "string" && SUPPORTED_COUNTRY_CODES.includes(value);
+}
+/** Country-gated UI features. Each key is a feature name; the value
+*  is the set of country codes for which the feature is enabled.
+*  Components ask `countryHasFeature("...", country)` instead of
+*  hard-coding country lists at the call site.
+*
+*  Add a new country-specific feature by adding a new key here and
+*  reading it via `countryHasFeature`. An unknown / undefined
+*  country never has any feature — components fall back to neutral
+*  default UI rather than guessing.
+*
+*  Mirrors the "Country-aware tax behaviour" prose in the
+*  Accounting role prompt (`src/config/roles.ts`). The two MUST
+*  stay in sync — drift means the LLM and the form give the user
+*  contradictory advice. The prompt is the source of truth for
+*  agent behaviour; this table is structured-data sibling for the
+*  form. */
+var COUNTRY_FEATURES = { 
+/** Show an amber "missing tax ID" warning + helper text on a
+*  postable 14xx (input-tax) line whose taxRegistrationId is
+*  blank. Limited to jurisdictions where the role prompt
+*  explicitly requires the counterparty registration number
+*  (JP T-number, EU VAT ID, GB VAT, GSTIN, ABN, NZ GST, CA BN).
+*  The "other countries" bucket and US (no federal sales-tax
+*  registration) intentionally stay quiet. 24xx output-tax
+*  lines don't trigger the warning — see `isTaxAccountCode`. */
+warnMissingTaxRegistrationId: /* @__PURE__ */ new Set([
+	"JP",
+	"GB",
+	"DE",
+	"FR",
+	"IT",
+	"ES",
+	"NL",
+	"BE",
+	"AT",
+	"IE",
+	"PT",
+	"FI",
+	"SE",
+	"DK",
+	"PL",
+	"IN",
+	"AU",
+	"NZ",
+	"CA"
+]) };
+/** Resolve a country-gated feature flag. Returns `false` when the
+*  country is undefined / unsupported — components default to the
+*  neutral path (no warning, no extra UI) rather than guessing. */
+function countryHasFeature(feature, country) {
+	if (!country) return false;
+	return COUNTRY_FEATURES[feature].has(country);
+}
+//#endregion
+//#region src/shared/currencies.ts
+/** ISO 4217 codes shown in the New Book dropdown. Curated for
+*  recognisability — Intl.DisplayNames provides the localised
+*  human name at render time, so this stays a flat list of codes. */
+var SUPPORTED_CURRENCY_CODES = [
+	"USD",
+	"EUR",
+	"JPY",
+	"GBP",
+	"CNY",
+	"KRW",
+	"TWD",
+	"HKD",
+	"SGD",
+	"AUD",
+	"CAD",
+	"CHF",
+	"INR",
+	"BRL",
+	"MXN"
+];
+var DEFAULT_FALLBACK_DIGITS = 2;
+/** Localised human name for a currency code. Falls back to the
+*  code itself if the runtime can't resolve the name. */
+function localizedCurrencyName(code, locale) {
+	try {
+		return new Intl.DisplayNames([locale], { type: "currency" }).of(code) ?? code;
+	} catch {
+		return code;
+	}
+}
+/** Number of fraction digits ISO 4217 specifies for a currency.
+*  JPY = 0, USD = 2, KWD = 3. Used both for amount formatting and
+*  for the HTML input step on debit/credit fields. */
+function fractionDigitsFor(currency) {
+	try {
+		return new Intl.NumberFormat("en", {
+			style: "currency",
+			currency
+		}).resolvedOptions().maximumFractionDigits ?? DEFAULT_FALLBACK_DIGITS;
+	} catch {
+		return DEFAULT_FALLBACK_DIGITS;
+	}
+}
+/** "1" for JPY, "0.01" for USD, "0.001" for KWD. Used as the HTML
+*  input step on debit/credit fields so a JPY book doesn't let the
+*  user type cents that would just round-trip back through the
+*  decimal validator. */
+function inputStepFor(currency) {
+	const digits = fractionDigitsFor(currency);
+	if (digits === 0) return "1";
+	return (1 / 10 ** digits).toFixed(digits);
+}
+/** Locale-aware currency formatter — returns "¥1,130" / "$1,130.00"
+*  etc. Falls back to fixed-point formatting if the runtime can't
+*  resolve the currency code; the fallback still respects the
+*  currency's natural fraction-digit count so JPY shows whole
+*  numbers even on the slow path. */
+function formatAmount(value, currency, locale) {
+	try {
+		return new Intl.NumberFormat(locale, {
+			style: "currency",
+			currency
+		}).format(value);
+	} catch {
+		return value.toFixed(fractionDigitsFor(currency));
+	}
+}
+/** Currency-agnostic amount formatter — "1,130.00" — for places that
+*  don't carry the currency code on the data path (compact preview
+*  envelopes etc.). Use `formatAmount(value, currency)` whenever the
+*  currency IS available — the currency-aware path picks the right
+*  fraction-digit count automatically (JPY = 0, USD = 2).
+*
+*  `locale` mirrors `formatAmount`'s signature: pass an explicit BCP-47
+*  locale (`"en-US"`, `"ja-JP"`, …) when the caller knows the desired
+*  grouping / digit-shape; omit to fall back to the runtime default. */
+function formatAmountNumeric(value, decimals = 2, locale) {
+	return value.toLocaleString(locale, {
+		minimumFractionDigits: decimals,
+		maximumFractionDigits: decimals
+	});
+}
+//#endregion
+//#region src/shared/dates.ts
+function pad2(num) {
+	return String(num).padStart(2, "0");
+}
+/** Today as `YYYY-MM-DD` in the user's local timezone. */
+function localDateString(now = /* @__PURE__ */ new Date()) {
+	return `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`;
+}
+/** Current month as `YYYY-MM` in the user's local timezone. */
+function localMonthString(now = /* @__PURE__ */ new Date()) {
+	return `${now.getFullYear()}-${pad2(now.getMonth() + 1)}`;
+}
+/** First day of the current calendar year as `YYYY-MM-DD`. */
+function localStartOfYearString(now = /* @__PURE__ */ new Date()) {
+	return `${now.getFullYear()}-01-01`;
+}
+/** Previous calendar month as `YYYY-MM` in the user's local timezone. */
+function previousMonthString(now = /* @__PURE__ */ new Date()) {
+	const target = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	return `${target.getFullYear()}-${pad2(target.getMonth() + 1)}`;
+}
+/** Last month of the previous calendar quarter as `YYYY-MM`. Calendar
+*  quarters: Q1=Jan–Mar, Q2=Apr–Jun, Q3=Jul–Sep, Q4=Oct–Dec. When the
+*  current month is in Q1, this rolls back to December of last year. */
+function lastMonthOfPreviousQuarterString(now = /* @__PURE__ */ new Date()) {
+	const firstMonthOfCurrentQuarter = Math.floor(now.getMonth() / 3) * 3;
+	const target = new Date(now.getFullYear(), firstMonthOfCurrentQuarter - 1, 1);
+	return `${target.getFullYear()}-${pad2(target.getMonth() + 1)}`;
+}
+/** December of the previous calendar year as `YYYY-MM`. */
+function decemberOfPreviousYearString(now = /* @__PURE__ */ new Date()) {
+	return `${now.getFullYear() - 1}-12`;
+}
+//#endregion
+//#region src/shared/timeSeriesEnums.ts
+var TIME_SERIES_METRICS = [
+	"revenue",
+	"expense",
+	"netIncome",
+	"accountBalance"
+];
+var TIME_SERIES_GRANULARITIES = [
+	"month",
+	"quarter",
+	"year"
+];
+//#endregion
+Object.defineProperty(exports, "ACCOUNTING_ACTIONS", {
+	enumerable: true,
+	get: function() {
+		return ACCOUNTING_ACTIONS;
+	}
+});
+Object.defineProperty(exports, "ACCOUNTING_API", {
+	enumerable: true,
+	get: function() {
+		return ACCOUNTING_API;
+	}
+});
+Object.defineProperty(exports, "ACCOUNTING_BOOKS_CHANNEL", {
+	enumerable: true,
+	get: function() {
+		return ACCOUNTING_BOOKS_CHANNEL;
+	}
+});
+Object.defineProperty(exports, "ACCOUNTING_DIRS", {
+	enumerable: true,
+	get: function() {
+		return ACCOUNTING_DIRS;
+	}
+});
+Object.defineProperty(exports, "ACCOUNT_TYPES", {
+	enumerable: true,
+	get: function() {
+		return ACCOUNT_TYPES;
+	}
+});
+Object.defineProperty(exports, "BALANCE_SHEET_ACCOUNT_TYPES", {
+	enumerable: true,
+	get: function() {
+		return BALANCE_SHEET_ACCOUNT_TYPES;
+	}
+});
+Object.defineProperty(exports, "BOOK_EVENT_KINDS", {
+	enumerable: true,
+	get: function() {
+		return BOOK_EVENT_KINDS;
+	}
+});
+Object.defineProperty(exports, "COUNTRY_FEATURES", {
+	enumerable: true,
+	get: function() {
+		return COUNTRY_FEATURES;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_FISCAL_YEAR_END", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_FISCAL_YEAR_END;
+	}
+});
+Object.defineProperty(exports, "EU_COUNTRY_CODES", {
+	enumerable: true,
+	get: function() {
+		return EU_COUNTRY_CODES;
+	}
+});
+Object.defineProperty(exports, "FISCAL_YEAR_END_MONTHS", {
+	enumerable: true,
+	get: function() {
+		return FISCAL_YEAR_END_MONTHS;
+	}
+});
+Object.defineProperty(exports, "SUPPORTED_COUNTRY_CODES", {
+	enumerable: true,
+	get: function() {
+		return SUPPORTED_COUNTRY_CODES;
+	}
+});
+Object.defineProperty(exports, "SUPPORTED_CURRENCY_CODES", {
+	enumerable: true,
+	get: function() {
+		return SUPPORTED_CURRENCY_CODES;
+	}
+});
+Object.defineProperty(exports, "TIME_SERIES_GRANULARITIES", {
+	enumerable: true,
+	get: function() {
+		return TIME_SERIES_GRANULARITIES;
+	}
+});
+Object.defineProperty(exports, "TIME_SERIES_METRICS", {
+	enumerable: true,
+	get: function() {
+		return TIME_SERIES_METRICS;
+	}
+});
+Object.defineProperty(exports, "bookChannel", {
+	enumerable: true,
+	get: function() {
+		return bookChannel;
+	}
+});
+Object.defineProperty(exports, "countryHasFeature", {
+	enumerable: true,
+	get: function() {
+		return countryHasFeature;
+	}
+});
+Object.defineProperty(exports, "currentFiscalYearRange", {
+	enumerable: true,
+	get: function() {
+		return currentFiscalYearRange;
+	}
+});
+Object.defineProperty(exports, "currentQuarterRange", {
+	enumerable: true,
+	get: function() {
+		return currentQuarterRange;
+	}
+});
+Object.defineProperty(exports, "decemberOfPreviousYearString", {
+	enumerable: true,
+	get: function() {
+		return decemberOfPreviousYearString;
+	}
+});
+Object.defineProperty(exports, "errorMessage", {
+	enumerable: true,
+	get: function() {
+		return errorMessage;
+	}
+});
+Object.defineProperty(exports, "fiscalYearEndMonth", {
+	enumerable: true,
+	get: function() {
+		return fiscalYearEndMonth;
+	}
+});
+Object.defineProperty(exports, "fiscalYearEndMonthLabel", {
+	enumerable: true,
+	get: function() {
+		return fiscalYearEndMonthLabel;
+	}
+});
+Object.defineProperty(exports, "formatAmount", {
+	enumerable: true,
+	get: function() {
+		return formatAmount;
+	}
+});
+Object.defineProperty(exports, "formatAmountNumeric", {
+	enumerable: true,
+	get: function() {
+		return formatAmountNumeric;
+	}
+});
+Object.defineProperty(exports, "fractionDigitsFor", {
+	enumerable: true,
+	get: function() {
+		return fractionDigitsFor;
+	}
+});
+Object.defineProperty(exports, "inputStepFor", {
+	enumerable: true,
+	get: function() {
+		return inputStepFor;
+	}
+});
+Object.defineProperty(exports, "isFiscalYearEnd", {
+	enumerable: true,
+	get: function() {
+		return isFiscalYearEnd;
+	}
+});
+Object.defineProperty(exports, "isSupportedCountryCode", {
+	enumerable: true,
+	get: function() {
+		return isSupportedCountryCode;
+	}
+});
+Object.defineProperty(exports, "lastMonthOfPreviousQuarterString", {
+	enumerable: true,
+	get: function() {
+		return lastMonthOfPreviousQuarterString;
+	}
+});
+Object.defineProperty(exports, "localDateString", {
+	enumerable: true,
+	get: function() {
+		return localDateString;
+	}
+});
+Object.defineProperty(exports, "localMonthString", {
+	enumerable: true,
+	get: function() {
+		return localMonthString;
+	}
+});
+Object.defineProperty(exports, "localStartOfYearString", {
+	enumerable: true,
+	get: function() {
+		return localStartOfYearString;
+	}
+});
+Object.defineProperty(exports, "localizedCountryName", {
+	enumerable: true,
+	get: function() {
+		return localizedCountryName;
+	}
+});
+Object.defineProperty(exports, "localizedCurrencyName", {
+	enumerable: true,
+	get: function() {
+		return localizedCurrencyName;
+	}
+});
+Object.defineProperty(exports, "previousFiscalYearRange", {
+	enumerable: true,
+	get: function() {
+		return previousFiscalYearRange;
+	}
+});
+Object.defineProperty(exports, "previousMonthString", {
+	enumerable: true,
+	get: function() {
+		return previousMonthString;
+	}
+});
+Object.defineProperty(exports, "previousQuarterRange", {
+	enumerable: true,
+	get: function() {
+		return previousQuarterRange;
+	}
+});
+Object.defineProperty(exports, "resolveFiscalYearEnd", {
+	enumerable: true,
+	get: function() {
+		return resolveFiscalYearEnd;
+	}
+});
+
+//# sourceMappingURL=shared-CcU3_qAa.cjs.map